11&12.分析排序、快排、归并

1如何分析一个“排序算法”？

1.1排序算法的执行效率

1. 最好情况、最坏情况、平均情况时间复杂度

2. 时间复杂度的系数、常数 、低阶

3. 比较次数和交换（或移动）次数

1.2排序算法的内存消耗

1.3排序算法的稳定性

 

1.4冒泡排序和插入排序的时间复杂度都是 O(n2)，都是原地排序算法，为什么插入排序要比冒泡排序更受欢迎呢？

冒泡排序中数据的交换操作：
if (a[j] > a[j+1]) { // 交换
   int tmp = a[j];
   a[j] = a[j+1];
   a[j+1] = tmp;
   flag = true;
}

插入排序中数据的移动操作：
if (a[j] > value) {
  a[j+1] = a[j];  // 数据移动
} else {
  break;
}

 

2快排、归并、堆排序

归并：稳定 空间复杂度O(n) 最差O(nlogn)

快排：不稳定 空间复杂度O(logn)~O(n) 最差O(n2)

堆排序：不稳定 空间复杂度O(1) 最差O(nlogn)

2.1快排

 

public static void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        int pivotIndex = partition(arr, start, end);
        quickSort(arr, start, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, end);
 }

 public static int partition(int[] arr, int start, int end) {
        dealPivot(arr,start,end);
        int pivot = arr[end];
        int i = start;
        for (int j = start; j <= end - 1; j++) {
            if (arr[j] < pivot) {
                swap(arr, i, j);
                i = i + 1;
            }
        }
        swap(arr, i, end);
        return i;
  }
public static void dealPivot(int[] arr, int left, int right) {
        int mid = (left + right) / 2;
        if (arr[left] > arr[mid]) {
            swap(arr, left, mid);
        }
        if (arr[left] > arr[right]) {
            swap(arr, left, right);
        }
        if (arr[right] < arr[mid]) {
            swap(arr, right, mid);
        }
        swap(arr, right , mid);
    }

2.2归并

private static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
        if (start >= end) {
            return;
        }
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        merge_sort_recursive(arr, result, start1, end1);
        merge_sort_recursive(arr, result, start2, end2);
        int index = start;
        while (start1 <= end1 && start2 <= end2)
            result[index++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        while (start1 <= end1)
            result[index++] = arr[start1++];
        while (start2 <= end2)
            result[index++] = arr[start2++];
        for (index = start; index <= end; index++)
            arr[index] = result[index];
    }

    public static void merge_sort(int[] arr) {
        int len = arr.length;
        int[] result = new int[len];
        merge_sort_recursive(arr, result, 0, len - 1);
    }

2.3findK

如何用快排思想在O(n)内查找第K大元素?

int findK(int[] arr, int k) {
        return findKRecur(arr, 0, arr.length - 1, k - 1);
    }

    int findKRecur(int[] arr, int start, int end, int k) {
        int pivot = QuickSort.partition(arr, start, end);
        if (pivot == k) {
            return arr[pivot];
        } else if (pivot < k) {
            return findKRecur(arr, pivot + 1, end, k);
        } else {
            return findKRecur(arr, start, pivot - 1, k);
        }
    }