排序学习（一）

最近学习了排序算法，今天对交换、选择、插入、单轴单向快排、堆、希尔排序进行编写以及耗时测试

基本的非线性排序算法分插入（希尔）、选择（堆）、交换（快排）、归并四类

这些算法都比较简单，所以就不讲解了（在最后附上源码）。今天主要是测试各个算法的耗时。

下图为该七种排序算法的复杂度（网上盗来的图）

测试一.十万个随机数

测试二.一百万个随机数

测试三.十万个顺序数

这里我没有加上快速排序，因为用快速排序算法对已排好序的数组进行排序会因递归调用太多次而出现stackoverflow

测试四.十万个逆序数

同样地，快排stackoverflow了

测试五.一千万个顺序数和逆序数（堆、希尔、归并）

以下为源码

交换（冒泡排序）

public static void sort(int[] a){
        int mark ;
        for (int i = 0; i < a.length ; i++){
            mark = 0;
            for (int j = 0; j < a.length-1 ; j++){
                if (a[j] > a[j+1]){
                    swap(a,j,j+1);
                    mark++;
                }
            }
            if (mark == 0)break;
        }
    }
    private static void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

选择排序

public static void sort(int[] a){
        for (int i = 0;i < a.length-1;i++){
            int min = i ;
            for (int j = i+1; j < a.length ; j++)
                if (a[min] > a[j])
                    min = j;
            if (min != i)
                swap(a,i,min);
        }
    }

插入排序

public static void sort(int[] a){
        for (int i = 1;i < a.length;i++){
            int temp = a[i];
            int j = i;
            for (;j > 0 && temp < a[j-1];j--)
                a[j] = a[j-1];
            a[j] = temp;
        }
    }

单轴快排

 public static void sort(int[] a){
        quickSort(a,0,a.length-1);
    }
    private static void quickSort(int[] a,int start,int end){
        if (start>=end)return;
        int pivot = a[start];
        int i = start, j = end;
        while (i < j){
            while (i < j && a[j] >= pivot)
                j--;
            while (i < j && a[i] <= pivot)
                i++;
            if (i < j)
                swap(a,i,j);
        }
        swap(a,start,j);
        quickSort(a,start,j-1);
        quickSort(a,j+1,end);
    }

堆排序

 public static void sort(int[] a){
        for (int i = (a.length-1)/2;i > -1;i--)
            adjustMaxHeap(a,i,a.length-1);
        heapSort(a);
    }
    //向下调整
    private static void  adjustMaxHeap(int[] a,int index,int size){
        int left = 2*index+1;
        if (left > size)return;
        int right = 2*index+2;
        int max = index;
        if (a[left] > a[max])
            max = left;
        if (right <= size && a[right] > a[max])
            max = right;
        swap(a,max,index);
        if(max!=index)
            adjustMaxHeap(a,max,size);
    }
    private static void heapSort(int[] a){
        for (int i = a.length-1;i > 0;i--){
            swap(a,0,i);
            //将最大堆堆顶与最后的数交换后继续调整成最大堆
            adjustMaxHeap(a,0,i-1);
        }
    }

希尔排序

public static void sort(int[] a){
        int jump = a.length/2;
        while (jump != 0){
            for (int i = jump;i < a.length;i++){
                int temp = a[i];
                int j = i;
                for (;j>=jump && temp < a[j-jump];j-=jump)
                    a[j] = a[j-jump];
                a[j] = temp;
            }
            jump/=2;
        }
    }