排序算法

写在前面：因为自己编程挺弱的，可能写的代码有瑕疵，并且有些没有优化（比如在快排时，选择基准值时就直接选择最前面的值），但是代码都能运行通过，欢迎交流与指出！

排序算法介绍

排序是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。

排序算法的稳定性：假设在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种排序算法的稳定的，否则称为不稳定的。

待排序的记录数量不同，使得排序过程中涉及的存储器不同，可将排序算法分为：内部排序（计算机随机存储器中进行排序），外部排序（待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中需要对外存进行访问的排序过程）

本文只讨论内部排序。

内部排序介绍

按排序过程中依据的不同原则对内部排序进行分类，大致可分为插入排序（直接插入排序、希尔排序）、交换排序（冒泡排序、快速排序）、选择排序（简单选择排序、堆排序）、归并排序和计数排序等五类。

下表给出了常见比较排序算法的性能：

常见比较排序算法的性能

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O(1)	稳定
简单选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
直接插入排序	O(n2)	O(n)	O(n2)	O(1)	稳定
希尔排序	O(nlogn)~O(n2)	O(n1.3)	O(n2)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n2)	O(logn)~O(n)	不稳定

冒泡排序

public static void bubbleSort(int[] num){
        if (num==null)
            return;

        for (int i=0; i<num.length-1; i++){ //遍历的趟数 n-1，每遍历一次就有一个数在规定的位置上
            boolean flag = true;  //判断是否已经排好序了，如果排好了，直接退出循环，优化部分

            // 从后向前开始冒泡。因为前i个元素已经为排好序的，所以判断范围为i到n-1，即比较到i+1和i为止，j到i+1。
            for (int j=num.length-1; j>i; j--){
                if (num[j] < num[j-1]){
                    int temp = num[j];
                    num[j] = num[j-1];
                    num[j-1] = temp;
                    flag = false; //如果有交换，说明并没有拍好序，继续下一趟排序。
                }
            }

            if (flag)
                break;
        }
    }

简单选择排序

选择排序的基本思想：每一趟在n-i+1(i=1,2,...,n-1)个记录中选出关键字最小的记录作为有序序列中的第i个记录。

public static void selectionSort(int[] num){
        if (num==null)
            return;

        //每次选择一个未排序数组中最小的放在开始处，一共需要n-1次
        for (int i=0; i<num.length-1; i++){
            int min = i; //将每次遍历开始的索引保存为min，之后min保存当前遍历中数值最小的索引。
            for (int j=i+1; j<num.length; j++){
                if (num[j] < num[min]){
                    min = j;
                }
            }

            //如果min不等于i，将最小的数值调换到i位置上
            if (i != min){
                int temp = num[i];
                num[i] = num[min];
                num[min] = temp;
            }
        }
    }

直接插入排序

基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。

public static void insertSort(int[] num){
        if (num==null)
            return;

        //因为给定的数组一般都是从下标为0开始的，如果将其作为哨兵，需要将其先整体往后挪，排完序后再挪回来
        //所以声明一个常数空间来存储元素,但是这样无法防止数组越界，需要自己判断
        for (int i=1; i<num.length; i++){
            if (num[i] < num[i-1]){ //可以不用这行判断，见希尔排序的写法
                int temp = num[i];  //复制为哨兵
                int j = i-1;
                //加入约束条件j>=0，并且要将其放在前面，不然数组越界
                while (j>=0 && temp<num[j]){
                    num[j+1] = num[j];
                    j--;
                }
                num[j+1] = temp;
            }
        }
    }

改进：折半插入排序、2-路插入排序

希尔排序

又称为“缩小增量排序”。基本思想：先将整个待排记录序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

//希尔排序
    //插入排序法可以高速处理顺序较整齐的数据，而希尔排序法就是充分发挥插入排序法这一特长的高速算法。
    public static void shellSort(int[] num){
        if (num==null || num.length==0)
            return;

        //生成数组G，表示间隔。因为G的大小不能确定，所以使用list
        List<Integer> G = new ArrayList<>();
        int h = 1;
        while (h<num.length){ 
            G.add(h);
            h = 3*h + 1;
        }

        for (int i=G.size()-1; i>=0; i--){
            insertionSortShell(num, G.get(i));
        }
    }

    public static void insertionSortShell(int[] num, int g){
        for (int i=g; i<num.length; i++){
            int temp = num[i];
            int j = i-g;
            while (j>=0 && num[j]>temp){
                num[j+g] = num[j];
                j -= g;
            }
            num[j+g] = temp;
        }
    }

快速排序

基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

快速排序的递归代码：

// r代表的是数组的最后一个元素
    public static int partition(int[] nums, int p, int r){
        int x = nums[r];
        int i = p-1;
        for (int j=p; j<r; j++){
            if (nums[j] <= x){
                i++;
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }

        int temp = nums[i+1];
        nums[i+1] = nums[r];
        nums[r] = temp;

        return i+1;
    }

    public static void quickSort(int[] nums, int p, int r){
        if (p < r){
            int q = partition(nums, p, r);
            quickSort(nums, p, q-1);
            quickSort(nums, q+1, r);
        }
    }

    public static void quickSort2(int[] nums, int l, int r){
        if (l>=r){
            return;
        }

        int i = l;
        int j = r;
        int key = nums[l];

        while (i<j){
            while (i<j && nums[j]>=key){
                j--;
            }
            if (i<j){
                nums[i] = nums[j];
                i++;
            }

            while (i<j && nums[i]<key){
                i++;
            }
            if (i<j){
                nums[j] = nums[i];
                j--;
            }
        }

        nums[i] = key;
        quickSort2(nums, l, i-1);
        quickSort2(nums, i+1, r);
    }

快速排序的非递归代码

public static void quickSortUnRec(int[] num, int start, int end){
        Stack<Integer> stack = new Stack<>(); //用栈模拟
        if (start < end){
            stack.push(end);
            stack.push(start);
            while (!stack.isEmpty()){
                int l = stack.pop();
                int r = stack.pop();
                int index = partition2(num, l, r);
                if (l < index-1){
                    stack.push(index-1);
                    stack.push(l);
                }
                if (r > index+1){
                    stack.push(r);
                    stack.push(index+1);
                }
            }
        }
    }

    private static int partition2(int[] num, int l, int r) {
        int pivot = num[l];
        while(l<r){
            while(l<r && num[r]>=pivot){
                r--;
            }
            if (l<r){
                num[l] = num[r];
                l++;
            }
            while(l<r && num[l]<pivot){
                l++;
            }
            if (l<r){
                num[r] = num[l];
                r--;
            }
        }
        num[l] = pivot;
        return l;
    }

递归算法使用的栈由程序自动产生，栈中包含：函数调用时的参数和函数中的局部变量。如果局部变量很多或者函数内部又调用了其他函数，则栈会很大。每次递归调用都要操作很大的栈，效率自然会下降。

而对于非递归算法，每次循环使用自己预先创建的栈，因此不管程序复杂度如何，都不会影响程序效率。

对于上面的快速排序，由于局部变量只有一个mid，栈很小，所以效率并不比非递归实现的低。

若初始记录序列按关键字有序或者基本有序时，快速排序将蜕化为起泡排序，时间复杂度为O(n²)，为改进之，通常依“三者取中”的法则来选取枢纽记录。

堆排序

使用的是最小堆，每次最小的值和最后一个元素交换，因此最后的排序是从大到小排序的。

堆排序的非递归代码：

public static void minHeapSort(int[] nums, int n){
        if (nums == null){
            return;
        }

        buildMinHeap(nums, n);

        for (int i=n-1; i>0; i--){
            int temp = nums[0];
            nums[0] = nums[i];
            nums[i] = temp;

            minHeapFixDown(nums, 0, i);
        }

    }

    private static void buildMinHeap(int[] nums, int n) {
        for (int i=(n-1)/2; i>=0; i--){
            minHeapFixDown(nums, i, n);
        }
    }

    private static void minHeapFixDown(int[] nums, int i, int n) {
        int j = 2*i+1;

        while (j < n){
            if (j+1<n && nums[j+1]<nums[j]){
                j++;
            }
            if (nums[i] <= nums[j]){
                break;
            }

            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;

            i = j;
            j = 2*i+1;
        }
    }

 堆排序的递归代码（只在调整堆的时候有变化）：

private static void minHeapFixDown2(int[] nums, int i, int n){
        int j = 2*i+1;

        if (j >= n){
            return;
        }

        if (j+1<n && nums[j+1]<nums[j]){
            j++;
        }
        if (nums[i] <= nums[j]){
            return;
        }

        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;

        minHeapFixDown2(nums, j, n);
    }

归并排序

假设初始序列有n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2(向上取整)个长度为2或1的有序子序列；再两两归并，...，如此重复，直至得到一个长度为n的有序序列为止，这种方法称为2-路归并排序。

归并排序的递归代码：

// right代表的是最后一个元素的后一个元素
    public static void mergeSort(int[] nums, int left, int right){
        if (left+1 < right){
            int mid = (left + right) / 2;
            mergeSort(nums, left, mid);
            mergeSort(nums, mid, right);
            merge(nums, left, mid, right);
        }
    }

    private static void merge(int[] nums, int left, int mid, int right) {
        int n1 = mid - left;
        int n2 = right - mid;

        int[] L = new int[n1+1];
        int[] R = new int[n2+1];
        for (int i=0; i<n1; i++){
            L[i] = nums[left+i];
        }
        for (int i=0; i<n2; i++){
            R[i] = nums[mid+i];
        }
        L[n1] = Integer.MAX_VALUE;
        R[n2] = Integer.MAX_VALUE;

        int i = 0;
        int j = 0;
        for (int k=left; k<right; k++){
            if (L[i] <= R[j]){
                nums[k] = L[i++];
            }else {
                nums[k] = R[j++];
            }
        }
    }

 归并排序的非递归代码（merge方法和上面一致）：

public static void mergeSortUnRec(int[] num){
        int len = 1;
        while (len <= num.length){

            for (int i=0; i+len<=num.length; i+=len*2){
                int low = i;
                int mid = i+len;
                int high = i+2*len;

                if (high>num.length){
                    high=num.length;
                }
                merge(num, low, mid, high);
            }
            len *= 2;
        }
    }

计数排序

先统计出每个数对应的个数（数组C），然后每个值都累加前面所有数的个数（数组C进行累加），最后从后向前面遍历所有数。

//假设输入的元素都是0到k之间的整数
    public static void countingSort(int[] A, int[] B, int k){

        int[] C = new int[k+1];
        for (int i=0; i<A.length; i++){
            C[A[i]]++;
        }

        for (int i=1; i<=k; i++){
            C[i] += C[i-1];
        }

        for (int i=A.length-1; i>=0; i--){
            B[C[A[i]]-1] = A[i];
            C[A[i]]--;
        }
    }

参考：

http://www.cnblogs.com/eniac12/p/5329396.html#s3

http://www.cnblogs.com/mist-lee/p/4770662.html

http://blog.csdn.net/pi9nc/article/details/12057381