1. 快速排序、归并排序

目录

快速排序

归并排序

---

快速排序

每一轮挑选基准元素，并让其他比它大的元素移动到数列一边，比它小的移动到数列一边，分治

平均时间复杂度：O(nlogn) 最好：O(n) 最差：O(n^2) ==> 基准元素pivot的选择（尽量随机，虽然使用时一般选择队首元素）

算法过程：

1. 确定边界点：一般为左边界、中间、随机

2. 调整区间：左边所有数小于pivot，右边所有数大于pivot

   • 双边循环法：left + right

         public static void quickSort(int[] nums, int l, int r) {
             if (l >= r) return;
             int x = nums[l + r >> 1];
     
             //Define positions of two pointers
             int i = l - 1;
             int j = r + 1;
     
             while (i < j) {
                 do i++; while (nums[i] < x);
                 do j--; while (nums[j] > x);
                 //do Swap
                 if (i < j) {
                     int temp = nums[i];
                     nums[i] = nums[j];
                     nums[j] = temp;
                 }
             }
     
             quickSort(nums, l, j);
             quickSort(nums, j + 1, r);
         }

   • 单边循环法：遍历数组，维护mark指针（小于基准元素的区域边界） ==> 只需一次循环，更为简易

     public static void quickSort(int[] nums, int start, int end) {
         //base case
         if (start >= end) return;
         //选择pivot、mark
         int pivot = nums[start], mark = start;
         for (int i = start + 1; i <= end; i++) {
             //如果nums[i] < pivot，mark++，交换mark和nums[i]；否则mark不变
             if (nums[i] < pivot) {
                 mark++;
                 int tmp = nums[mark];
                 nums[mark] = nums[i];
                 nums[i] = tmp;
             }
         }
         //交换mark和pivot位置元素
         nums[start] = nums[mark];
         nums[mark] = pivot;
     	//递归左右两侧
         quickSort(nums, start, mark - 1);
         quickSort(nums, mark + 1, end);
     }

3. 递归处理左右两极

使快速排序成为稳定排序 ==> 确保每个元素不同，构造二元组index和value

归并排序

归并排序：将两个或两个以上的有序表合并成一个有序表的过程，将两个有序表合并成一个有序表的过程称为2-路归并

时间复杂度：O(nlogn)

算法过程：

1. mid = left + (right - left)/2
2. 递归排序左右两侧
3. 归并左右两侧 ==> 双指针合并

public static void mergeSort(int[] nums, int start, int end) {
    // base case
    if (start >= end) return;
    // 取中点，递归排序左右两侧
    int mid = start + end >> 1;
    mergeSort(nums, start, mid);
    mergeSort(nums, mid + 1, end);
    // 对两部分进行归并排序
    int i = start, j = mid + 1, k = 0;
    int[] tmp = new int[end - start + 1];
    while (i <= mid && j <= end) tmp[k++] = nums[i] <= nums[j] ? nums[i++] : nums[j++];
    while (i <= mid) tmp[k++] = nums[i++];
    while (j <= end) tmp[k++] = nums[j++];
    System.arraycopy(tmp, 0, nums, start, k);
}