面试常见算法-排序查找算法

算法是程序员必被的一个技能，在面试中常常出现，下面总结了面试中出现的常见算法，这些算法程序员应该牢记在心中，要非常熟练。

插入排序算法

原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。

要点：设立哨兵，作为临时存储和判断数组边界之用。

public class InsertSort {
   private static void insertSort(int[] a) {
       int j;
       int tmp;
       for (int i = 1; i < a.length; i++) {
           tmp = a[i];
           for (j = i; j > 0 && tmp < a[j - 1]; j--) {
                a[j] = a[j - 1];
           }
           a[j] = tmp;
       }
    }
}

希尔排序算法

原理：又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。

要点：增量的选择以及排序最终以1为增量进行排序结束。

public class ShellSort {
    private static void shellSort(int[] a) {
        int j;
        int tmp;
        for (int gap = a.length / 2; gap >0; gap /= 2) {
            for (int i = gap; i < a.length;i++) {
                tmp = a[i];
                for (j = i; j >= gap && tmp< a[j - gap]; j -= gap) {
                    a[j] = a[j - gap];
                }
                a[j] = tmp;
            }
        }
    }
}

冒泡排序算法

原理：将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。

要点：设计交换判断条件，提前结束以排好序的序列循环。

public class BubbleSort {
   private static void bubbleSort(int[] a) {
        for (int i = 0; i < a.length - 1;i++) {
           for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
           }
       }
    }
   private static void swap(int[] a, int x, int y) {
       int tmp = a[x];
       a[x] = a[y];
       a[y] = tmp;
    }
}

快速排序算法

原理：不断寻找一个序列的中点，然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。

要点：递归、分治

public class QuickSort {
   private static void quickSort(int[] a) {
       quickSort(a, 0, a.length - 1);
    }
   private static void quickSort(int[] a, int left, int right) {
       if (left < right) {
           int pivot = a[left];
           int lo = left;
           int hi = right;
           while (lo < hi) {
                while (lo < hi &&a[hi] >= pivot) {
                    hi--;
                }
                a[lo] = a[hi];
                while (lo < hi &&a[lo] <= pivot) {
                    lo++;
                }
                a[hi] = a[lo];
           }
           a[lo] = pivot;
           quickSort(a, left, lo - 1);
           quickSort(a, lo + 1, right);
       }
    }
}

简单选择排序算法

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序

public class SelectSort {
   private static void selectSort(int[] a) {
       int idx;
       for (int i = 0; i < a.length; i++) {
           idx = i;
           for (int j = i + 1; j < a.length; j++) {
                if (a[idx] > a[j]) {
                    idx = j;
                }
           }
           swap(a, idx, i);
       }
    }
   private static void swap(int[] a, int x, int y) {
       int tmp = a[x];
       a[x] = a[y];
       a[y] = tmp;
    }
}

堆排序算法

原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

要点：建堆、交换、调整堆

public class HeapSort {
   private static void heapSort(int[] a) {
       // 先创建大堆，从第一个非叶子结点开始调整，然后调整第二个非叶子结点...
       for (int i = a.length / 2; i >= 0 ; i--) {
           shiftDown(a, i, a.length);
       }
       // 调整大堆，将最大的元素调整到未排好序的部分的末尾
       for (int i = a.length - 1; i > 0 ; i--) {
           swap(a, 0, i);
           shiftDown(a, 0, i);
       }
    }
   private static void shiftDown(int[] a, int i, int n) {
       int child;
       int tmp;
       for (tmp = a[i]; i * 2 + 1 < n; i = child) {
           child = i * 2 + 1;
           if (child != n - 1 && a[child] < a[child + 1]) {
                child++;
           }
           if (tmp < a[child]) {
                a[i] = a[child];
            } else {
                break;
           }
       }
       a[i] = tmp;
    }
   private static void swap(int[] a, int x, int y) {
       int tmp = a[x];
       a[x] = a[y];
       a[y] = tmp;
    }
}

归并排序算法

原理：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。

要点：归并、分治

public class MergeSort {
   private static void mergeSort(int[] a) {
       int[] b = new int[a.length];
       mergeSort(a, b, 0, a.length - 1);
    }
   private static void mergeSort(int[] a, int[] b, int left, int right) {
       if (left < right) {
           int center = left + (right - left) / 2;
           mergeSort(a, b, left, center);
           mergeSort(a, b, center + 1, right);
           merge(a, b, left, center + 1, right);
       }
    }
   private static void merge(int[] a, int[] b, int leftPos, int rightPos, intrightEnd) {
       int leftEnd = rightPos - 1;
       int tempPos = leftPos;
       int numElements = rightEnd - leftPos + 1;

       while (leftPos <= leftEnd && rightPos <= rightEnd) {
           if (a[leftPos] <= a[rightPos]) {
                b[tempPos] = a[leftPos];
                tempPos++;
                leftPos++;
           } else {
                b[tempPos] = a[rightPos];
                tempPos++;
                rightPos++;
           }
       }
       while (leftPos <= leftEnd) {
           b[tempPos] = a[leftPos];
           tempPos++;
           leftPos++;
       }
       while (rightPos <= rightEnd) {
           b[tempPos] = a[rightPos];
           tempPos++;
           rightPos++;
       }
       for (int i = 0; i < numElements; i++, rightEnd--) {
           a[rightEnd] = b[rightEnd];
       }
    }
}

二分查找算法

public class BinarySearch {
   public static int binarySearch(int[] a, int v) {
       int mid;
       int lo = 0;
       int hi = a.length - 1;
       while (lo <= hi) {
           mid = lo + ((hi - lo) >>> 1); // 移位运算的优先级比较低，要用括号
           if (a[mid] == v) { // 已经找到
                return mid;
           } else if (a[mid] < v) { // 可能在右边
                lo = mid + 1;
           } else { // 可能在左边
                hi = mid - 1;
           }
       }
       return -1; // 未找到
    }
}