数据结构七大排序（Java）

1.插入排序： 每次选择无序区间的第一个元素，在有序区间内选择合适的位置进行插入

```java

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

2 希尔排序：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。（实际上为插入排序的优化）

    public static void shellSort(int []array){
        int gap = array.length;  //gap表示一次筛选的步长
        while(gap>1){
            InsertSortWithGap(array,gap);
            gap = gap/2;
        }
        InsertSortWithGap(array,1);
    }

    private static void InsertSortWithGap(int[] array, int gap) {
        for(int i = gap ;i<array.length;i++){
            int k = array[i];
            int j ;
            for(j = i-gap;j>=0;j-=gap){
                if(array[j]>k){
                    array[j+gap]= array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=k; 
        }
    }

3、选择排序：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

    public static void selectSort(int []array){
        for(int i =0;i<array.length-1;i++){
            int max = 0;
            for(int j = 1;j<array.length-i;j++){
                if(array[j]>array[max]){
                    max = j;
                }
            }
            swap(array,max,array.length-1-i);
        }
    }
    private static void swap(int[] array, int max, int i) {
        int t = array[max];
        array[max] = array[i];
        array[i] = t;
    }

4、堆排序：通过堆来选择无序区间的最大的数。

  public static void heapSort(int []array){
        CreatHeap(array);
        for(int i = 0;i<array.length-1;i++){
            swap(array,0,array.length-1-i);//建立大堆  将最后个数和大堆的堆首交换  再进行向下调整
            shifDownBig(array,array.length-1-i,0);
        }
    }
    public static void CreatHeap(int []array){
        for(int i =(array.length-2)/2;i>=0;i--){  //最后1个的结点的双亲结点
            shifDownBig(array,array.length,i);
        }
    }
    public static void shifDownBig(int []array,int size,int index){
        int left = 2*index+1;
        while(left<size) {
            int right = left + 1;
            int max = left;
            if (right < size) {
                if (array[left] < array[right]) max = right;
            }
            if(array[max]<=array[index])
                break;

            swap(array,index,max);
            index = max;
            left = 2*index+1;
        }
    }

5、冒泡排序：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

    public static void bubbleSort(int []array){
        for(int i = 0;i<array.length;i++){
            for(int j = 0;j<i;j++){
                if(array[i]<array[j]){
                    swap(array,i,j);
                }
            }
        }
    }
       private static void swap(int[] array, int max, int i) {
        int t = array[max];
        array[max] = array[i];
        array[i] = t;
    }

6、快速排序：

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

  public static  void qulicSort(int []array){
        quickSortINter(array,0,array.length-1);
    }
    public static void quickSortINter(int []array,int left ,int right){
        if(right<=left)
            return ;
        int val  = patition3x(array,left,right);
        quickSortINter(array,left,val-1);
        quickSortINter(array,val+1,right);
    }
    public static int patition3x(int []array, int left ,int right){ //将最大的元素放到数组的最右边
        int reference_Val = array[right];
        int d = right-1;
        for(int i =right-1;i>=0;i--){
            if(array[i]>reference_Val){
                swap(array,d,i);
                d--;
            }
        }
        swap(array,d+1,right);
        return d+1;
    }



  public static int patition3 (int[]array, int left, int right){  //将最小的元素放到数组最左端
        int reference_val = array[left];    
        int d = left+1;
        for(int i = left+1;i<=right;++i){
            if(array[i]<reference_val){
                swap(array,i,d++);
            }
        }
        swap(array,d-1,left);
        return d-1;
    }




    private static int patition1(int[] array, int left, int right) {
        int began = left;
        int end = right;
        int maink = array[left];
        while(end > began){
            while(end > began && array[end] >= maink){
                end --;
            }
            while (end > began && maink >= array[began]){
                began ++;
            }

            swap(array,end,began);
        }
        swap(array,left,began);
        return end;
    }
    public static int patition2(int []array,int left ,int right){  //挖坑法
        int begin = left;
        int end = right;
        int reference_val = array[left];
        while(end>begin){
            while(end>begin && array[end]>=reference_val){
                end --;
            }
            array[begin] = array[end];
            while(end>begin && array[begin]<= reference_val){
                begin ++;
            }
            array[end] = array[begin];
        }
        array[begin] = reference_val;
        return  begin;
    }

7、归并排序：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

 public static  void mergeSort(int []array){   
        int []extra = new int [array.length];
        mergeINter(array,0,array.length,extra);
    }

    private static void mergeINter(int[] array, int low, int high, int[] extra) {
        if(low >=high-1){
            return;
        }
        int mid = (low+high)/2;
        mergeINter(array,low,mid,extra);
        mergeINter(array,mid,high,extra);
        merge(array,low ,mid ,high,extra);
    }

    public static void merge(int []array,int low ,int mid, int high,int []extra){
        int i = low;
        int j = mid;
        int len = high- low;
        int k =0;
        while(i<mid&&j<high){
            if(array[i]>array[j]){
                extra[k++] = array[j++];
            }
            else {
                extra[k++] = array[i++];
            }
        }
        while(i<mid){
            extra[k++] = array[i++];
        }while(j<high){
            extra[k++] = array[j++];
        }
        for(int m = 0; m <len;m++){
            array[low+m] = extra[m];
         }
    }