数据结构-排序

**

基础排序

**
1、冒泡排序

2、选择排序

每次选择最小值的索引,与首位进行交换
时间复杂度：O(n2)

public class Selection {
    public static void sort(Comparable[] a) {

        for (int i = 0; i < a.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (greater(a[minIndex], a[j])) {
                    minIndex = j;
                }
            }
            exch(a, i, minIndex);
        }
    }
    private static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

3、插入排序

1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待
插入元素放到这个位置，其他的元素向后移动一位；
时间复杂度：O(n2)

public class Insertion {
    public static void sort(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if (greater(a[j - 1], a[j])) {
                    exch(a, j - 1, j);
                } else {
                    break;
                }
            }
        }
    }
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }
    public static void exch(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

**

高级排序

**
4、希尔排序

分组插入排序
O(n^(1.3—2))

public class Shell {
    public static void sort(Comparable[] a) {
        int N = a.length;
        int h =1;
        while (h<N/2){
            h=2*h+1;
        }
        while (h>=1){
            for (int i = h; i < N; i++) {
                for (int j = i; j >=h; j-=h) {
                    if (greater(a[j - h], a[j])) {
                        exch(a, j - h, j);
                    } else {
                        break;
                    }
                }
            }
            h/=2;
        }
    }
    public static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }
    public static void exch(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

5、归并排序

O(NlogN)

public class Merge {

    private static Comparable[] assist;//归并所需要的辅助数组


    public static void sort(Comparable[] a) {
        assist = new Comparable[a.length];
        int lo = 0;
        int hi = a.length-1;
        sort(a, lo, hi);
    }

    private static void sort(Comparable[] a, int lo, int hi) {
        if (hi <= lo) {
            return;
        }

        int mid = lo + (hi - lo) / 2;
        sort(a, lo, mid);
        sort(a, mid + 1, hi);
        merge(a, lo, mid, hi);

    }

    private static void merge(Comparable[] a, int lo, int mid, int hi) {
        int i = lo;
        int p1 = lo;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= hi) {
            if(less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }

        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        while (p2<=hi){
            assist[i++]=a[p2++];
        }

        for (int index=lo;index<=hi;index++){
            a[index]=assist[index];
        }
    }

    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

6、快速排序

O(NlogN)

public class Quick {
    public static void sort(Comparable[] a) {

        int lo = 0;
        int hi = a.length-1;
        sort(a, lo, hi);
    }
    private static void sort(Comparable[] a, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int partition = partition(a, lo, hi);
        sort(a,lo,partition-1);
        sort(a,partition+1,hi);

    }
    private static int partition(Comparable[] a, int lo, int hi) {
        Comparable key = a[lo];
        int left = lo;
        int right = hi+1;
        while (true){
            while (less(key,a[--right])){
                if(right==lo){
                    break;
                }
            }
            while (less(a[++left],key)){
                if(left==hi){
                    break;
                }
            }
            if(left>=right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        exch(a,lo,right);
        return right;//right就是切分的界限
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

稳定性：

稳定：冒泡排序 插入排序  归并排序
不稳定：选择排序 希尔排序 快速排序