排序算法实现

插入排序

基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

public class InsertionSort {
    public int[] insertionSort(int[] A, int n) {
        for(int i = 1; i<n; i++){
              //如果与前一个数对比，大于前一个数，不进行对换。
             for(int j = i; j > 0 && A[j]<A[j-1]; j--){
                int temp = A[j];
                A[j] = A[j-1];
                A[j-1] = temp;
            }
        }
        return A;
    }
}

------------------------------------------------------------------------------------------------------------------------------------

希尔排序

基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

public class ShellSort {
    public int[] shellSort(int[] A, int n) {
        // write code here
        int D,j;
        for(D = n/2; D>0; D /= 2){

            for(int i=D; i<n; i++){
                int temp = A[i];
                for(j=i; j>=D && A[j-D]>temp; j-=D){
                    A[j] = A[j-D];
                }
                A[j] = temp;
            }

        }
        return A;
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------

堆排序

public class HeapSort {
    public int[] heapSort(int[] A, int n) {
        for(int i=n/2-1; i>= 0; i--)
            sink(A, i, n);
        for(int j=n-1; j > 0; j--){
            swap(A, 0, j);
            sink(A, 0, j);
        }
        return A;
    }
    private void swap(int[] A, int m, int n){
        int temp = A[m];
        A[m] = A[n];
        A[n] = temp;
    }
    private void sink(int[] A, int p, int n){
        int parent,child;
        int x;
        x = A[p];
        for(parent = p; (2*parent+1)<n; parent=child){
            child=2*parent+1;
            if((child != n-1) && A[child]<A[child+1])
                child++;
            if(x>A[child])
                break;
            else
                A[parent] = A[child];
        }
        A[parent] = x;
    }
}

-----------------------------------------------------------------------------------------------------------------------------------------

归并排序

  归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。（速度快 nlogn ,需要占用被排序相同大小的内存空间） 缺点：占用内存空间

public class MergeSort {

    public int[] mergeSort(int[] A, int n) {
        // write code here
        sort(A, 0, n-1);
        return A;
    }

    public void sort(int[] 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);
    }

    public void merge(int[] A, int lo, int mid, int hi){
        int i = lo, j = mid+1;
        int[] B = new int[A.length];
        for(int k = lo; k <= hi; k++){
            B[k] = A[k];
        }

        for(int k = lo; k <= hi; k++){
            if(i > mid)
                A[k] = B[j++];
            else if(j > hi)
                A[k] = B[i++];
            else if(B[i] > B[j])
                A[k] = B[j++];
            else
                A[k] = B[i++];
        }
    }
}

-----------------------------------------------------------------------------------------------------------------------------------------------------

快速排序

基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

public class QuickSort {
    public int[] quickSort(int[] A, int n) {
        // write code here
        sort(A, 0, n-1);
        return A;
    }
    public void sort(int[] A, int lo, int hi){
        if(hi <= lo) return;
        int j = partition(A, lo, hi);
        sort(A, lo, j-1);
        sort(A, j+1, hi);
    }

    public int partition(int[] A, int lo, int hi){
        int i = lo, j = hi+1;
        int v = A[lo];
        while(true){
            while(A[++i] < v){
                if(i == hi){
                    break;
                }
            }
            while(v < A[--j]){
                if(j == lo){
                    break;
                }
            }
            if(i >= j)
                break;
            exch(A, i, j);
        }
        exch(A, lo, j);
        return j;
    }

    public void exch(int[] A, int i, int j){
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------

选择排序

public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        // write code here
        for(int i=0;i<n;i++){
            for(int j=i+1; j<n;j++){
                if(A[j]<A[i]){
                    int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
                }

            }

        }
       return A;
    }
}

------------------------------------------------------------------------------------------------------------------------------------------------------------

冒泡排序

public class BubbleSort {
    public int[] bubbleSort(int[] A, int n) {
        // write code here
        // write code here
        int temp = 0;
        for(int i = 0;i < n-1;i++){
            for(int j = 0;j<n-i-1;j++){
                if(A [j] > A [j+1]){
                    temp = A[j];
                    A[j] = A[j+1];
                    A[j+1] = temp;
                }
            }
        }
        return A;
    }
}