快速排序和归并排序

排序：

所谓排序，即将原本无序的序列重新排列成有序序列的过程。

稳定性：

稳定性：当待排序列中有两个或两个以上相同的关键字时，排序前和排序后这些关键字的相对位置，如果没有发生变化就是稳定的，否则就是不稳定的。

快速排序：

快速排序是“交换”类的排序，它通过多次划分操作实现排序。每趟选择一个关键字（通常是第一个），比关键字小的放在左边，比关键字大的放在右边；左右子序列重复执行上述操作。

public void quickSort(int[] nums, int low, int high) {
        if (nums==null||nums.length==0) {
            return;
        }
        int temp;
        int i=low, j=high;
        if (low<high) {
            temp=nums[low];
            while (i!=j) {
                while (j>i&&nums[j]>=temp) {
                    j--;
                }
                if (i<j) {
                    nums[i]=nums[j];
                    i++;
                }
                while (i<j&&nums[i]<temp) {
                    i++;
                }
                if (i<j) {
                    nums[j]=nums[i];
                    j--;
                }
            }
            nums[i]=temp;
            quickSort(nums, low, i-1);
            quickSort(nums, i+1, high);
        }

    }

快速排序最好情况下的时间复杂度为O(nlogn)，待排序列越接近无序，本算法效率越高。最坏情况下的时间复杂度为O(n^2)，待排序列越接近有序，本算法效率越低，平均时间复杂度为O(nlogn)。空间复杂度为O(logn)。

归并排序：

归并排序可以看作一个分而治之的过程，先将整个序列分为两半，对每一半分别进行归并排序，将得到两个有序序列，然后将这两个序列归并成一个序列即可。

public void mergeSort(int[] nums, int low, int high) {
        if (low<high) {
            int mid = (low+high)/2;

            mergeSort(nums, low, mid);
            mergeSort(nums, mid+1, high);
            merge(nums, low, mid, high);
        }
    }
    void merge(int[] nums, int low, int mid, int high) {
        int i=low;
        int j=mid+1;
        int k=0;
        int[] temp = new int[high-low+1];
        while (i<=mid&&j<=high) {
            if (nums[i]<=nums[j]) {
                temp[k]=nums[i];
                i++;
            } else {
                temp[k]=nums[j];
                j++;
            }
            k++;
        }
        while (j<=high) {
            temp[k]=nums[j];
            k++;
            j++;
        }
        while (i<=mid) {
            temp[k]=nums[i];
            k++;
            i++;
        }

        for (int l = 0; l < temp.length; l++) {
            nums[low+l]=temp[l];
        }
    }

归并排序的时间复杂度和初始化序列无关，即平均情况下为O(nlogn)，最好情况下为O(nlogn)，最坏情况下为O(nlogn)。

空间复杂度：因归并排序需要转存整个待排序列，因此空间复杂度为O(n)。

快速排序是不稳定的排序算法，归并排序是稳定的排序算法。