排序

1.冒泡排序

　　关键词：两两比较

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

通过逐一比较相邻两个数的大小，并将较大数放在较小数之后（反之亦然），第一轮过后最大（小）的数将在最后，以此类推。

2.选择排序

　　关键词：选取最小（大）数

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

选取最小（大）数放于起始位置，再从剩余元素中寻找最小（大）数。第一轮，将第一个数依次与其他元素比较大小，将较小者放入第一个元素位子（互换位置），即第一轮找出了最小元素并置于起始位置，第二轮则找出第2小的元素置于第2个位置。以此类推

3.插入排序

　　关键词：左侧元素已排好序

/**
     * 插入排序
     * @param a
     */
    public static void insertSort(int[] a){
        for(int i=1;i<a.length;i++){
            for(int j=i;(j>0)&&(a[j]<a[j-1]);j--){
                swap(a, j, j-1);
            }
        }
    }
    /**
     * 交换
     * @param a
     * @param i
     * @param j
     */
    public static void swap(int[] a,int i,int j){
        int temp = 0;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

插入排序算法有种递归的思想在里面，它由N-1趟排序组成。初始时，只考虑数组下标0处的元素，只有一个元素，显然是有序的。

然后第一趟 对下标 1 处的元素进行排序，保证数组[0,1]上的元素有序；

第二趟 对下标 2 处的元素进行排序，保证数组[0,2]上的元素有序；

.....

.....

第N-1趟对下标 N-1 处的元素进行排序，保证数组[0,N-1]上的元素有序，也就是整个数组有序了。

它的递归思想就体现在：当对位置 i 处的元素进行排序时，[0,i-1]上的元素一定是已经有序的了。

 4.快速排序

　　关键 ;大的问题分割为更小的问题

/**
     * 一轮排序,基准点左侧的元素都小于基准点，右侧的元素都大于基准点
     * @param a
     * @param low
     * @param high
     * @return
     */
    public static int partition(int[] a,int low ,int high){
        int key = a[low];//基准点
        
        while(low<high){
            //从后向前扫描
            while(a[high]>=key&&high>low){
                high--;
            }
            a[low]=a[high];
            //从前向后扫描
            while(a[low]<=key && high>low){
                low++;
            }
            a[high] = a[low];
        }
        a[high] = key;
        return high;
    }
    
    /**
     * 递归 
     * @param a
     * @param low
     * @param high
     */
    public static void quickSort(int[] a,int low,int high){
        if(low>high){
            return;
        }
        //分割点
        int index = partition(a, low, high);
        //左侧排序
        quickSort(a, low, index-1);
        //右侧排序
        quickSort(a, index+1, high);
    }

选取一个基准点（例子中以下标为low的元素作为基准点），让基准点左侧元素都小于基准点，右侧元素都大于基准点，在将左侧元素作为一个数组进行相同操作（右侧相同）。

5.归并排序

　　关键：已经排序的两个序列合并为一个序列

/**
     * 归并排序
     * @param a
     * @param low
     * @param high
     */
    public static void mergeSort(int[] a,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
            mergeSort(a, low, mid);
            mergeSort(a, mid+1, high);
            merge(a, low, mid, high);
        }
    }
    
    /**
     * 归并，将两个有序列 合并为一个有序列
     * @param a
     * @param low
     * @param mid
     * @param high
     */
    public static void merge(int[] a,int low,int mid,int high){
        int[] temp = new int[high-low+1];//归并后的序列
        int i = low,j=mid+1,k=0;
        //将较小的数依次放入temp中
        while(i<=mid&&j<=high){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else{
                temp[k++] = a[j++];
            }
        }
        //将剩余数放入temp
        while(i<=mid){
            temp[k++]=a[i++];
        }
        while(j<=high){
            temp[k++]=a[j++];
        }
        //覆盖a
        for(int x=0;x<temp.length;x++){
            a[low+x] = temp[x];
        }
    }

将序列分割为单个元素，再两两归并。