八大排序算法

文字说明部分转载自http://blog.csdn.net/hguisu/article/details/7776068
排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
我们这里说说八大排序就是内部排序。

当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
**（1）直接插入排序：一般插入排序，比较是从有序序列的最后一个元素开始，如果比它大则直接插入在其后面，否则一直往前比。如果找到一个和插入元素相等的，那么就插入到这个相等元素的后面。插入排序是稳定的。
（2）希尔排序：希尔排序是按照不同步长对元素进行插入排序，一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，稳定性就会被破坏，所以希尔排序不稳定。
（3）简单选择排序：在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。光说可能有点模糊，来看个小实例：858410，第一遍扫描，第1个元素8会和4交换，那么原序列中2个8的相对前后顺序和原序列不一致了，所以选择排序不稳定。
（4）堆排序：堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, …这些父节点选择元素时，有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，所以堆排序并不稳定。
（5）冒泡排序：由前面的内容可知，冒泡排序是相邻的两个元素比较，交换也发生在这两个元素之间，如果两个元素相等，不用交换。所以冒泡排序稳定。
（6）快速排序：在中枢元素和序列中一个元素交换的时候，很有可能把前面的元素的稳定性打乱。还是看一个小实例：6 4 4 5 4 7 8 9，第一趟排序，中枢元素6和第三个4交换就会把元素4的原序列破坏，所以快速排序不稳定。
（7）归并排序：在分解的子列中，有1个或2个元素时，1个元素不会交换，2个元素如果大小相等也不会交换。在序列合并的过程中，如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，所以，归并排序也是稳定的。
（8）基数排序：是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
8种排序的分类，稳定性，时间复杂度和空间复杂度总结：
**

package Sort_eight;

public class sort {
    public static void main(String[] args) {
        int[] array1 = { 46, 24, 76, 98, 14, 7, 58 };
        System.out.println("插入排序：-直接插入--n^2");
        insertSort(array1, array1.length);
        System.out.println("-----------");

        System.out.println("插入排序：-希尔排序");
        int[] array2 = { 46, 24, 76, 98, 14, 7, 58 };
        shellInsertSort(array2,array2.length);
        System.out.println("-----------");

        System.out.println("交换排序：-冒泡排序");
        int[] array3 = { 46, 24, 76, 98, 14, 7, 58 };
        bubbleSort(array3,array3.length);
        System.out.println("-----------");

        System.out.println("交换排序：-快速排序");
        int[] array4 = { 46, 24, 76, 98, 14, 7, 58 };
        quickSort(array4,array4.length);
        System.out.println("-----------");

        System.out.println("选择排序：-简单选择排序");
        int[] array5 = { 46, 24, 76, 98, 14, 7, 58 };
        simpleSelectSort(array5,array5.length);
        System.out.println("-----------");

        System.out.println("选择排序：-堆排序");
        int[] array6 = { 46, 24, 76, 98, 14, 7, 58 };
        heapSort(array6,array6.length);
        System.out.println("-----------");

        System.out.println("二路归并排序");
        int[] array7 = { 46, 24, 76, 98, 14, 7, 58 };
        mergeSort(array7,0,array7.length-1);
        print(array7);
        System.out.println("-----------");

        System.out.println("桶/基数排序");
        int[] array8 = { 46, 24, 76, 98, 14, 7, 58 };
        radixSort(array8,100);
        System.out.println("-----------");

    }

    //1.插入排序—直接插入排序(Straight Insertion Sort)---n^2
    public static void insertSort(int[] array, int length) {
        // TODO Auto-generated method stub
        if (array != null) {
            for (int i = 1; i < length; i++) {
                if (array[i] < array[i - 1]) {
                    int temp = array[i], j = i;
                    while (j >= 1 && array[j - 1] > temp) {
                        array[j] = array[j - 1];
                        j--;
                    }
                    array[j] = temp;
                }
            }
        }
        print(array);
    }
    //2. 插入排序—希尔排序（Shell`s Sort）---n*logn
    //-又叫缩小增量排序
    public static void shellInsertSort(int[] array, int length) {
        // TODO Auto-generated method stub
        for(int gap=length/2;gap>0;gap/=2){
            for(int i=gap;i<length;i++){
                for(int j=i-gap;j>=0&&array[j]>array[j+gap];j=j-gap){
                    swap(array,j,j+gap);
                }
            }
        }
        print(array);
    }

    //3.交换排序—冒泡排序（Bubble Sort）-----n^2

    private static void bubbleSort(int[] array, int length) {
        // TODO Auto-generated method stub
        for(int i=0;i<length-1;i++){
            for(int j=length-1;j>i;j--){
                if(array[j]<array[j-1]){
                    swap(array, j-1, j);
                }
            }
        }
        print(array);
    }

    //4.交换排序—快速排序（Bubble Sort）在复习一下！！！！
    private static void quickSort(int[] array, int length) {
        // TODO Auto-generated method stub
        qSort(array,0,length-1);
        print(array);
    }

    private static void qSort(int[] array, int low, int high) {
        // TODO Auto-generated method stub
        int i = low, j = high, index;
        if (low >= high)
            return;
        index = array[i];
        while (i < j) {
            while (i < j && array[j] >= index) {
                j--;
            }
            if (i < j) {
                array[i] = array[j];
                i++;
            }
            while (i < j && array[i] < index) {
                i++;
            }
            if (i < j) {
                array[j] = array[i];
                j--;
            }
        }
        array[i] = index;
        qSort(array, low, i - 1);
        qSort(array, i + 1, high);
    }

    //5.交换排序—简单选择排序（Bubble Sort）

    private static void simpleSelectSort(int[] array, int length) {
        // TODO Auto-generated method stub
        for(int i=0;i<length;i++){
            int indexmin=array[i];
            for(int j=i+1;j<length;j++){
                if(array[j]<indexmin){
                    int temp=indexmin;
                    indexmin=array[j];
                    array[j]=temp;
                }
            }
            array[i]=indexmin;
        }
        print(array);
    }

    //6.交换排序—堆排序（Bubble Sort）

    private static void heapSort(int[] array, int length) {
        // TODO Auto-generated method stub
        //暂时未看懂--2016-03-05 21:18
        //2017年9月14 22:24完成
        int n = length;

        // 第一步：初始化堆，将所有有子节点的节点向下沉。注意下标
        for(int k = length/2;k>=1;k--) {
            sink(array,k,n);
        }

        // 第二步：将堆顶和数组最后一个数交换，再将新的堆顶元素下降
        while (n>1) {
            exch(array,1,n--);
            sink(array,1,n);
        }
        print(array);
    }

    // 下降元素
    private static void sink(int[] array, int k, int n) {
        // TODO Auto-generated method stub
        while(2*k<=n) {
            int j = 2*k;
            // 比较左右子树，选出其中最大的
            if(j<n && less(array,j,j+1)) {
                j++;
            }
            // 如果大于最大的，就不降
            if(less(array,k,j)) {
                break;
            }
            // 和最大的元素交换
            exch(array, k, j);
            k = j;
        }
    }

    // 交换元素
    private static void exch(int[] array, int i, int j) {
        // TODO Auto-generated method stub
        int temp = array[j-1];
        array[j-1] = array[i-1];
        array[i-1] = temp;
    }
    //比较元素
    private static boolean less(int[] array, int i, int j) {
        // TODO Auto-generated method stub
        return array[i-1]<array[j-1];
    }

    // 7.交换排序—二路归并排序（Bubble Sort）

    private static void mergeSort(int[] array, int low, int high) {
        // TODO Auto-generated method stub
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(array, low, mid);
            mergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

    private static void merge(int[] array, int low, int mid, int high) {
        // TODO Auto-generated method stub
        int n1=mid-low+1,n2=high-mid;
        int i=0,j=0,k=0;
        int[] l=new int[n1];
        int[] h=new int[n2];
        for(i=0, k=low;i<n1;k++,i++){
            l[i]=array[k];
        }
        for(k=mid+1,i=0;i<n2;k++,i++){
            h[i]=array[k];
        }

        for(i=0,j=0,k=low;i<n1&&j<n2;k++){
            if(l[i]<h[j]){
                array[k]=l[i];
                i++;
            }
            else{
                array[k]=h[j];
                j++;
            }
        }
        if(i<n1){
            for(j=i;j<n1;j++,k++){
                array[k]=l[j];
            }
        }
        if(j<n2){
            for(i=j;i<n2;i++,k++){
                array[k]=h[i];
            }
        }
    }

    // 8.交换排序—桶/基数排序（Bubble Sort）

    private static void radixSort(int[] array,int d) {
        // TODO Auto-generated method stub
        int n = 1, length = array.length;
        int index = 0,k=0;
        int[][] bucket = new int[10][length];
        int[] number = new int[10];
        while (n < d) {
            for (int num : array) {
                index = (num / n) % 10;
                bucket[index][number[index]] = num;
                number[index]++;
            }

            for (int i = 0; i < 10; i++) {
                if (number[i] != 0) {
                    for (int j = 0; j < number[i]; j++) {
                        array[k++] = bucket[i][j];
                    }
                }
                number[i]=0;
            }
            n*=10;
            k=0;
        }
        print(array);
    }




    public static void swap(int a[], int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    private static void print(int[] array) {
        // TODO Auto-generated method stub
        for (int number : array) {
            System.out.print(number + " ");
        }
    }
}