归并排序，快速排序算法分析

归并排序，快速排序；

像冒泡排序，插入排序，选择排序这样的排序算法，他们的时间复杂度都是O(n^2),适合小规模的排序。
有两种时间复杂度为O(n log n)的排序算法：归并，快速排序；比较适合大规模的数据排序；

归并，快速排序都用分治算法；

归并排序

思路

如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。

代码

public class MergeSort {

  // 归并排序算法, a是数组，n表示数组大小
  public static void mergeSort(int[] a, int n) {
    mergeSortInternally(a, 0, n-1);//Internally内部
  }

  // 递归调用函数
  private static void mergeSortInternally(int[] a, int p, int r) {
    // 递归终止条件
    if (p >= r) return;

    // 取p到r之间的中间位置q,防止（p+r）的和超过int类型最大值
    int q = p + (r - p)/2;
    // 分治递归
    mergeSortInternally(a, p, q);
    mergeSortInternally(a, q+1, r);

    // 将A[p...q]和A[q+1...r]合并为A[p...r]
    merge(a, p, q, r);
  }

  private static void merge(int[] a, int p, int q, int r) {
    int i = p;
    int j = q+1;
    int k = 0; // 初始化变量i, j, k
    int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组，存放合并之后的数据
    while (i<=q && j<=r) {//数组左侧或者右侧下标都在规定范围之内
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等于i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }
      //循环之后左右两侧有剩余数据未比较

    // 判断哪个左右子数组中有剩余的数据
    int start = i;
    int end = q;
      //合并之后，左边或者右边可能有一方有剩余元素。
    if (j <= r) {//条件成立 说明右侧有剩余元素；
      start = j;
      end = r;
    }

    // 将剩余的数据拷贝到临时数组tmp
    while (start <= end) {
      tmp[k++] = a[start++];
    }

    // 将tmp中的数组拷贝回a[p...r]
    for (i = 0; i <= r-p; ++i) {
      a[p+i] = tmp[i];
    }
  }

使用哨兵合并：

  /**
   * 合并(哨兵)
   *
   * @param arr
   * @param p
   * @param q
   * @param r
   */
  private static void mergeBySentry(int[] arr, int p, int q, int r) {
    int[] leftArr = new int[q - p + 2];
    int[] rightArr = new int[r - q + 1];

    for (int i = 0; i <= q - p; i++) {
      leftArr[i] = arr[p + i];
    }
    // 第一个数组添加哨兵（最大值）
    leftArr[q - p + 1] = Integer.MAX_VALUE;

    for (int i = 0; i < r - q; i++) {
      rightArr[i] = arr[q + 1 + i];
    }
    // 第二个数组添加哨兵（最大值）
    rightArr[r-q] = Integer.MAX_VALUE;

    int i = 0;
    int j = 0;
    int k = p;
    while (k <= r) {
      // 当左边数组到达哨兵值时，i不再增加，直到右边数组读取完剩余值，同理右边数组也一样
      if (leftArr[i] <= rightArr[j]) {
        arr[k++] = leftArr[i++];
      } else {
        arr[k++] = rightArr[j++];
      }
    }
  }
}

算法分析

是否稳定：归并排序稳定性主要取决于merge()函数，如果在合并的过程中有相同的元素就可以把前面的数组先放入目标数组即可。可以保证相同元素合并前后顺序不变。所以，她是一个稳定的排序算法。

时间复杂度：分析时间复杂度要结合递归进行分析。归并排序的执行效率与要排序的原始数组的有序程度无关，所以其时间复杂度是非常稳定的，不管是最好情况、最坏情况，还是平均情况，时间复杂度都是 O(nlogn)。

空间复杂度：空间复杂度是 O(n)。归并排序没有应用广泛一个“弱点”，就是他并不是一个原地排序的算法。在合并两个有序数组的时候，需要借助额外的存储空间。

快速排序

思路

快速排序利用分治思想。从一组数据中的下标p到r之间，任选一个数据作为分区点。遍历从p到r之间的数据，将小于分区点的放在左边，大于分区点的放在右边。这样数据带分区点在内被分成三个部分。同时递归排序左右两部分数据，知道区间缩小为1，就说明所有的数据都有序了。

代码

public class QuickSort {

  // 快速排序，a是数组，n表示数组的大小
  public static void quickSort(int[] a, int n) {
    quickSortInternally(a, 0, n-1);
  }

  // 快速排序递归函数，p,r为下标
  private static void quickSortInternally(int[] a, int p, int r) {
    if (p >= r) return;

    int q = partition(a, p, r); // 分割后的数组，获取分区点
    quickSortInternally(a, p, q-1);
    quickSortInternally(a, q+1, r);
  }

  private static int partition(int[] a, int p, int r) {
    int pivot = a[r];//最后一个数组元素作为分区点
    int i = p;
    for(int j = p; j < r; ++j) {
      if (a[j] < pivot) {//数组元素小于分区点
        if (i == j) {//下标相等
          ++i;
        } else {//
          int tmp = a[i];
          a[i++] = a[j];//i换位置的时候也要自增
          a[j] = tmp;
        }
      }
    }

    int tmp = a[i];
    a[i] = a[r];
    a[r] = tmp;

    System.out.println("i=" + i);
    return i;
  }
}

分析

是否稳定：不稳定;

时间复杂度：同样适用递归代码实现的；T(n) 在大部分情况下的时间复杂度都可以做到 O(n log n)，只有在极端情况下，才会退化到 O(n^2);

空间复杂度：o(1);不需要额外的空间；

对比归并：归并排序的处理过程是由下到上的，先处理子问题，然后再合并。而快排正好相反，它的处理过程是由上到下的，先分区，然后再处理子问题。归并排序虽然是稳定的、时间复杂度为 O(n log n) 的排序算法，但是它是非原地排序算法。快速排序通过设计巧妙的原地分区函数，可以实现原地排序，解决归并排序占用太多内存的问题。