经典【排序算法】总结

1. 二分查找

算法描述：

• 在有序的数组内，查找target值的索引

注意：

• 注意 l 指针和 r 指针最后的指向

private static int binarySearch(int[] array, int target) {
     int l = 0;
     int r = array.length - 1;
     while (l <= r) {
         int mid = l + (r - l) / 2;
         if (array[mid] == target) {
             return mid;
         } else if (array[mid] < target) {
             l = mid + 1;
         } else {
             r = mid - 1;
         }
     }
     return -1;
}

2. 冒泡排序

算法思想：

• 每次从第 0 个元素开始，依次比较相邻的两个元素。如果后一个比前一个大，则进行交换。
• 之后的内循环比较次数，内循环的次数就会减一个，因为上一轮已经把最大的元素移动到了末尾。
• 优化：如果能够判断某一轮的内循环没有进行交换元素，则说明数组已经有序，则直接退出循环

private static void bubbling(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j] > array[j + 1]){
                    flag = true;
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            if (!flag) {
                break;
            }
        }
}

3. 选择排序

算法思想：

• 将数组分成有序区和无序区。一开始整个数组是无序区。
• 每次从无序区中找到最小元素的下标，然后与无序区的第一个元素进行交换。

private static void selectionSort(int[] array){
    for (int i = 0; i < array.length; i++) {
        int min_idx = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[min_idx]) {
                min_idx = j;
            }
        }
        int temp = array[i];
        array[i] = array[min_idx];
        array[min_idx] = temp;
    }
}

4. 插入排序

算法思想：

• 将数组分成有序区和无序区。一开始数组的第一个元素是有序区，后面都是无序区。
• 遍历无序区的元素，将插入插入到有序区对应的位置上。

private static void insertSort(int[] array){
    for (int i = 1; i < array.length; i++) {
        if(array[i] < array[i - 1]){
            int temp = array[i];
            int idx = i - 1;
            while(idx >= 0 && array[idx] > temp){
                array[idx + 1] = array[idx];
                idx--;
            }
            array[++idx] = temp;
        }
    }
}

5. 快速排序

算法思想：

• 挑选一个元素作为基准元素。
• 把比基准元素小的放在基准元素左侧，比基准元素大的放到右侧。此时就完成了一轮分区。
• 递归的对左右两个分区进行相同的操作。分治思想
• 缺点：如果选取最左侧或最右侧的元素最为基准点，对于已经有序的数组进行快速排序，则会退化成冒泡排序。因为：每一次只能使数组减少一个元素，而最优的情况应该是每次分区操作都能将数组一分为二。

private static void quickSorting(int[] array, int l, int r){
    if(l >= r){
        return;
    }
    // 基准点下标
    int index = partition(array, l, r);
    // 左边分区一趟排序
    quickSorting(array, l, index - 1);
    // 右边分区一趟排序
    quickSorting(array, index + 1, r);
 }

 private static int partition(int[] array, int l, int r){
     int val = array[l];
     int i = l;
     while(i < r){
         while (i < r && array[r] > val){
             r--;
         }
         while (i < r && array[r] <= val){
             i++;
         }
         swap(array, i, r);
     }
     swap(array, l, i);
     return i;
 }

 private static void swap(int[] array, int j, int i) {
     int temp = array[i];
     array[i] = array[j];
     array[j] = temp;
 }

6. 归并排序

算法思想：

• 归并排序分为两部分，分解和合并
• 分解：将待排序的序列，一分为二，直到分成单个元素时，则认为是有序的了。
• 合并：将有序的序列进行合并，形成一个有序的大序列。通过不断的合并最终得到完全排序好的序列。

private static void mergeSort(int[] array, int l, int r){
        if (l >= r) {
            return;
        }
        int mid = l + (r - l) / 2;
        mergeSort(array, l, mid);
        mergeSort(array, mid + 1, r);
        merge(array, l, mid, r);
    }

    /**
     *
     * @param array
     * @param left 表示第一个子数组的起始位置。
     * @param mid 表示第一个子数组的结束位置，也是第二个子数组的起始位置-1
     * @param right 表示第二个子数组的结束位置。
     */
    private static void merge(int[] array, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right) {
            if(array[i] <= array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
            }
        }
        while(i <= mid) {
            temp[k++] = array[i++];
        }
        while(j <= right) {
            temp[k++] = array[j++];
        }
        for(int p = 0; p < temp.length; p++) {
            array[left + p] = temp[p];
        }
    }

7. LRU

8. LFU