常用排序算法（冒泡、选择、归并、快排、插入）

冒泡排序（时间复杂度On^2 空间复杂度O1)稳定

步骤：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

    //冒泡排序改进版
    public static void Bubble(int res[]){
        boolean flag = true;
        for(int i = 0;i<res.length&&flag;i++){
            flag = false;
            for(int j=0;j<res.length-i-1;j++){
                if(res[j]>res[j+1]){
                    int temp = res[j];
                    res[j]   = res[j+1];
                    res[j+1] = temp;
                    flag = true;
                }
            }
        }
    }

选择排序：（时间复杂度On^2 空间复杂度O1)不稳定

    //选择排序
    void SelectSort(int a[]){
        int temp;
        int length = a.length;
        for(int i=0;i<length-1;i++){
            int index = i;
            for(int j=i+1;j<length;j++){
                if(a[j]>a[index]){
                    index=j;
                }
            }
            if(i!=index){
            temp=a[i];
            a[i]=a[index];
            a[index]=temp;
        }
        }
        for(int i=0;i<length;i++){
            System.out.print(" "+a[i]);
        }
        System.out.println();
    }

归并排序 时间复杂度O(nlogn)，而空间复杂度是O(n) 稳定

是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用
将一个数组递归划分成子集，直到划分到已经排序好了，在进行递归合并

public class MergeSort {

    public static void Merge(int a[],int begin,int end){
        if(begin==end)
            return;
        else{
        int[] res= new int[1000];
        int mid = (begin+end)/2;
        Merge(a,begin,mid);
        Merge(a,mid+1,end);
        MergrSort(a,res,begin,mid,end);
            for(int i=begin;i<=end;i++){
                a[i] = res[i];
            }
        }
    }

    public static void MergrSort(int a[],int res[],int begin,int mid,int end){
        int k= begin;
        int i=begin,j=mid+1;
        for(;i<=mid&&j<=end;k++){
            if(a[i]<a[j])
                res[k]=a[i++];
            else
                res[k]=a[j++];
        }
        while(i<=mid)
            res[k++]=a[i++];
        while(j<=end)
            res[k++]=a[j++];
    }
}

快速排序：（时间复杂度O nlog2(n) 空间复杂度O nlog2(n))不稳定

1从数列中挑出一个元素，称为 “基准”（pivot），
2重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

 static public void Qsort(int a[],int begin,int end){
        if(begin<end){
            int mid = Pattinon(a,begin,end);
            Qsort(a,begin,mid-1);
            Qsort(a,mid+1,end);
        }
    }

    static public int Pattinon(int a[],int begin,int end){
        int keypoint = a[begin];
        while(begin<end){
            while(begin<end&&a[end]>=keypoint)
                end--;
            a[begin] = a[end];
            while (begin<end&&a[begin]<=keypoint)
                begin++;
            a[end] = a[begin];
        }
        a[begin] = keypoint;
        return begin;
    }

插入排序：（时间复杂度On^2 空间复杂度O1)稳定

步骤：

1从第一个元素开始，该元素可以认为已经被排序
2取出下一个元素，在已经排序的元素序列中从后向前扫描
3如果该元素（已排序）大于新元素，将该元素移到下一位置
4重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5将新元素插入到该位置中
6重复步骤2

//插入排序
public static void Insert(int[] res){
        for(int i = 1;i<res.length;i++){
            if(res[i]<res[i-1]){
                res[0] = res[i];
                int j = i-1;
                for(;res[j]>res[0];j--){
                    res[j+1] = res[j];
                }
                res[j+1] = res[0];
            }
        }
    }