java数据结构之排序

写在前面的话：本篇文章是我自己阅读程杰老师的大话数据结构之后自己所做的总结，网上有很多关于排序的详细介绍，我推荐伍迷家园所写的文章，介绍的非常详细。

排序是我们在程序中经常要用到的一种算法，好的排序可以极大的提高我们的工作效率，本篇主要介绍几种常见的排序算法；

 （简单说明：下面的java程序是用来排序的，其中sum为排序数组，sum[0]不进行排序，只作为哨兵或者临时变量）

1、冒泡排序：冒泡排序是一种交换排序，其的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

//冒泡排序2 最正宗的冒泡排序，i每循环一次，最小的数就像气泡一样慢慢浮到水面上
    public static void BubbleSort_2(int[] num){
        for(int i = 1; i < num.length; i++){
            for(int j = num.length-1; j > i; j--){
                if(num[j-1] > num[j]){
                    Swap(num,j-1,j);    //交换函数  交换num[j-1]和num[j]的值
                }
            }
        }
    }

2、选择排序：简单选择排序法（Simple Selection Sort）就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1≤i≤n)个记录交换之。

//选择排序
    public static void SelectSort(int[] num){
        int min;
        for(int i = 1; i < num.length; i++){
            min = i;
            for(int j = i + 1; j <num.length; j++){
                if(num[min] > num[j]){
                    min = j;
                }
            }
            if(i != min){
                Swap(num,i,min);        //交换函数  交换num[j-1]和num[j]的值
            }
        }
    }

3、插入排序：直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

 //插入排序
    public static void InsertSort(int[] num){
        int j;                             
        for(int i = 2; i < num.length; i++){
            if(num[i] < num[i-1]){
                num[0] = num[i];
                for( j = i-1; num[j] > num[0]; j--){
                    num[j+1] = num[j];          //记录右移
                }
                num[j+1] = num[0]; //插入到正确位置
                num[0] = 0;         //把num[0] 置为0，还回到初始值
            }
        }
    }

4、希尔排序：我们将原本有大量记录数的记录进行分组。分割成若干个子序列，此时每个子序列待排序的记录个数就比较少了，然后在这些子序列内分别进行直接插入排序，当整个序列都基本有序时，注意只是基本有序时，再对全体记录进行一次直接插入排序。

//希尔排序
    public static void ShellSort(int[] num){
        int n = num.length; 
        int j;
        do{
            n = n/3 + 1;                    //增量序列
            for(int i = n; i < num.length; i++){
                if(num[i] < num[i-n]){          //需要将num[i]插入到有序增量子表中
                    num[0] = num[i];
                    for(j = i - n; j > 0 && num[0] < num[j];j -= n){
                        num[j+n] = num[j];
                    }
                    num[j+n] = num[0];
                }
            }
        }while(n > 1);
    }

5、堆排序：堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它与堆数组的末尾元素进行交换，此时末尾元素就是最大值，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复执行，便能得到一个有序序列了。（大顶堆：在完全二叉树中，每个结点的值都大于或等于其左右孩子结点的值）

 //堆排序算法   堆排序的时候一定要注意数组的下标，很容发生数组下标越界的情况
    public static void HeadSort(int[] num){
        for(int i = (num.length-1)/2; i>0; i--){        //将num构建成一个大顶堆
        HeapAdjust(num,i,num.length-1);
        }
        for(int i = num.length-1; i > 1; i--){     //排序num[3]~num[n]  其中数组开始两个元素num[1]和num[2]没有进行交换
            Swap(num,1,i);                            //交换函数  交换num[j-1]和num[j]的值
            HeapAdjust(num,1,i-1);
        }
    }
    /*本函数是为了将num调整为一个大顶堆，num除了num【1】以外，
    其他节点都符合大顶堆的定义，这个函数是为堆排序算法服务的*/
    public static void HeapAdjust(int[] num,int start,int stop){            
        int i, num_x;
        num_x = num[start];
        for(i = 2*start; i <= stop; i*=2){       //沿关键字较大的纪录项下筛选
            if(i+1 >= num.length){                //没有右孩子节点时，单独判断，否则num[i+1]会越界
                if(num[i/2] < num[i]){
                    num[i/2] = num[i];
                    start = i;
                 break;
              }else{
                  break;
              }
            }
            if(num[i] < num[i+1] && i < stop){
                ++i;                        //i为关键字较大的记录的下标 
            }
            if(num_x >= num[i]){                 //不在向下找了，num_x已经是最大的了
                break;
            }
            num[start] = num[i];
            start = i;
        }
        num[start] = num_x;
    }

6、归并排序：归并排序（Merging Sort）就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归 并，得到⌈n/2⌉（⌈x⌉表示不小于x的最小整数）个长度为2的有序子序列；再两两归并，……     如此重复，直至得到一个长度为n的有序序列为止，这 种排序方法称为2路归并排序。

//归并排序
    public static void MergeSort(int[] num){
        int[] temp =new int[num.length];
        MSort(num,temp ,1,num.length-1);
    }
    //Msort函数是将list数组进行分割，Merge函数是将分割后的list数组进行排序在组合
    public static void MSort(int[] list ,int[] temp,int left,int right){
        if(left  == right){
            return;   
        }else{
            int m = (left + right) / 2;
            MSort(list,temp,left,m);
            MSort(list,temp,m+1,right);
            Merge(list,temp,left,m+1,right);
        }
    }
    public static void Merge(int[] list,int[] temp,int left,int mid,int right){
        int j = 0;
        int left_x = left;
        int mid_x = mid -1;
        int n = right - left +1;                        //当前temp数组中数的个数
        while(left <= mid_x &&  mid <= right){              //左右数组第一个数进行比较  把较小的数如到temp数组中
            if(list[left] < list[mid]){
                temp[j++] = list[left++];
            }else{
                temp[j++] = list[mid++];
            }
        }
        while(left <= mid_x){                         //如果左边的数比右边的数多，就将剩下的入到temp数组中    j
            temp[j++] = list[left++];
        }

        while(mid <= right){                           //如果右边打数比左边的数多，就将右边剩下的数加入到temp数组当中去
            temp[j++] = list[mid++];
        }
        
        for(j = 0; j < n; j++){             //   将得到的temp数组加到list数组中    
            list[left_x+j] = temp[j];
        }         
    }

 7、快速排序：快速排序（Quick Sort）的基本思想是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

//快速排序
    public static void QuickSort(int[] num){
        QSort(num,1,num.length-1);
    }
    public static void QSort(int[] num, int left, int right){
        int mid = Partition(num,left,right);

        QSort(num,left,mid-1);
        QSort(num,mid+1,right); 
    }
    //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
    public static int   Partition(int[] num, int left, int right){
        int result;
        result = num[left];
        while(left < right){
            while( left < right && num[right] >= result){
                right++;
            }
            Swap(num,left,right);
            while( left < right && num[left] <= result){
                left++;
            }
            Swap(num,left,right);
        }
        return left;
    }

 8、快速排序优化

 //快速排序优化
    public static void QuickSort_Op(int[] num){
        Qsort_Op(num,1,num.length-1);
    }
    public static void Qsort_Op(int[] num, int left, int right){
        final int N = 7;                //数组长度的阀值  当数组长度低于这个长度是就不在使用快速排序，而是使用插入排序
        if((right-left) > N){
            //尾递归优化
            while(left < right){
                int mid = Partition_Op(num,left,right);
        
                Qsort_Op(num, left, mid-1);        //对底子表进行递归排序
                left = mid;            //尾递归
            }
         }else{              //当right-left小于7时，用直接插入排序
               InsertSort(num);  
         }
   }
  //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
    public static int Partition_Op(int[] num, int left, int right){
        int result;

        //优化选取轴承    三数取中（取左端、右端，中间三个），进行排序，取中间数作为轴承
        int m = left + (right - left);
        if(num[left] > num[right]){
            Swap(num,left,right);
        }
        if(num[m] > num[right]){
            Swap(num,m,right);
        }
        if(num[left] < num[m]){
            Swap(num,left,m);
        }
        result  = num[left];         //y用子表的第一个记录作为轴承记录
        num[0] = result;            //将轴承关键字备份到num[0]
        while( left < right ){
            while(left < right && num[right] > result){
                right--;
            }
            num[left] = num[right];  //选择替换而不是交换方式进行
            while(left < right && num[left] < result){
                left++;
            }
            num[right] = num[left];         //选择替换而不是交换方式进行操作
        }
        num[left] = num[0];
        return left;
    }

 下面代码包含了上述所有排序算法，是一段总结代码：

/**
 * 2016/5/3
 * 排序算法大总结
 * 说明：本java程序是用来排序的，其中sum为排序数组，sum[0]不进行排序，只作为哨兵或者临时变量
 */
package cn.Link;
public class Sort{
    //测试主函数
    public static void main(String[] args){
        int n = 20;         //数组长度
        int[] num = new int[n];     //要排序的数组
        num[0] = 0;             //数组首位不进行排序操作，仅作为临时变量或者是哨兵
        for(int i = 1; i < n; i ++){
            num[i] = (int)(Math.random()*100);  //随机生成一个数作为数组元素
        }

        System.out.println("排序前的数组：");
        Print_num(num);

        //冒泡排序1
        int[] num_1 = (int[]) num.clone();        //将num数组全部复制给num_1数组
        BubbleSort_1(num_1);
        System.out.print("
冒泡排序1排序后的结果");
        Print_num(num_1);

        //冒泡排序2
        int[] num_2 = (int[]) num.clone();        //将num数组全部复制给num_2数组
        BubbleSort_2(num_2);
        System.out.print("
冒泡排序2排序后的结果：");
        Print_num(num_2);

        //冒泡排序3 对冒泡排序2的优化
        int[] num_3 = (int[]) num.clone();        //将num数组全部复制给num_3数组
        BubbleSort_3(num_3);
        System.out.print("
冒泡排序3排序后的结果：");
        Print_num(num_3);

        //选择排序
        int[] num_4 = (int[]) num.clone();        //将num数组全部复制给num_4数组
        SelectSort(num_4);
        System.out.print("
选择排序排序后的结果：");
        Print_num(num_4);

        //插入排序
        int[] num_5 = (int[])num.clone();        //将num数组全部复制给num_5数组
        InsertSort(num_5);
        System.out.print("
插入排序排序后的结果");
        Print_num(num_5);
        
        //希尔排序
        int[] num_6 = (int[])num.clone();        //将num数组全部复制给num_6数组
        InsertSort(num_6);
        System.out.print("
希尔排序排序后的结果");
        Print_num(num_6);

        //堆排序
        int[] num_7 = (int[])num.clone();        //将num数组全部复制给num_7数组
        HeadSort(num_7);
        System.out.print("
堆排序排序后的结果");
        Print_num(num_7);
        
        //堆排序
        int[] num_8 = (int[])num.clone();        //将num数组全部复制给num_8数组
        MergeSort(num_8);
        System.out.print("
归并排序排序后的结果");
        Print_num(num_8);
        
        //快速排序
        int[] num_9 = (int[])num.clone();        //将num数组全部复制给num_8数组
        MergeSort(num_9);
        System.out.print("
快速排序排序后的结果");
        Print_num(num_9);
        
      //快速排序优化
        int[] num_10 = (int[])num.clone();        //将num数组全部复制给num_8数组
        MergeSort(num_10);
        System.out.print("
快速排序优化后排序后结果");
        Print_num(num_10);

    }

    //交换数组中的两个数
    public static void Swap(int[]num,int i,int j){
        int num_x;
        num_x = num[i];
        num[i] = num[j];
        num[j] = num_x;
    }

    //遍历输出一个数组
    public static void Print_num(int[] num){
        System.out.println();
        for(int u:num){            //for-each 
            System.out.print(u+" ");
        }
    }

    //冒泡排序1  最简单的两两比较，反序则交换的排序
    public static void BubbleSort_1(int[]num){
        for(int i = 1; i < num.length; i++){
            for(int j = i+1; j < num.length; j++){
                if(num[i] > num[j]){
                    Swap(num,i,j);
                }
            }
        }
    }

    //冒泡排序2 最正宗的冒泡排序，i每循环一次，最小的数就像气泡一样慢慢浮到水面上
    public static void BubbleSort_2(int[] num){
        for(int i = 1; i < num.length; i++){
            for(int j = num.length-1; j > i; j--){
                if(num[j-1] > num[j]){
                    Swap(num,j-1,j);    //交换函数  交换num[j-1]和num[j]的值
                }
            }
        }
    }

    //冒泡排序3  对冒泡排序的优化
    public static void BubbleSort_3(int[] num){
        boolean  flag = true;
        for(int i = 1; i < num.length && flag; i++){
            flag = false;                   //flag初始化为假
            for(int j = num.length-1; j>i ; j--){
                if(num[j-1] > num[j]){
                    Swap(num,j-1,j);        //交换函数  交换num[j-1]和num[j]的值
                    flag = true;
                }
            }
        }
    }

    //选择排序
    public static void SelectSort(int[] num){
        int min;
        for(int i = 1; i < num.length; i++){
            min = i;
            for(int j = i + 1; j <num.length; j++){
                if(num[min] > num[j]){
                    min = j;
                }
            }
            if(i != min){
                Swap(num,i,min);        //交换函数  交换num[j-1]和num[j]的值
            }
        }
    }

    //插入排序
    public static void InsertSort(int[] num){
        int j;                             
        for(int i = 2; i < num.length; i++){
            if(num[i] < num[i-1]){
                num[0] = num[i];
                for( j = i-1; num[j] > num[0]; j--){
                    num[j+1] = num[j];          //记录右移
                }
                num[j+1] = num[0]; //插入到正确位置
                num[0] = 0;         //把num[0] 置为0，还回到初始值
            }
        }
    }
    //希尔排序
    public static void ShellSort(int[] num){
        int n = num.length; 
        int j;
        do{
            n = n/3 + 1;                    //增量序列
            for(int i = n; i < num.length; i++){
                if(num[i] < num[i-n]){          //需要将num[i]插入到有序增量子表中
                    num[0] = num[i];
                    for(j = i - n; j > 0 && num[0] < num[j];j -= n){
                        num[j+n] = num[j];
                    }
                    num[j+n] = num[0];
                }
            }
        }while(n > 1);
    }

    //堆排序算法   堆排序的时候一定要注意数组的下标，很容发生数组下标越界的情况
    public static void HeadSort(int[] num){
        for(int i = (num.length-1)/2; i>0; i--){        //将num构建成一个大顶堆
        HeapAdjust(num,i,num.length-1);
        }
        for(int i = num.length-1; i > 1; i--){     //排序num[3]~num[n]  其中数组开始两个元素num[1]和num[2]没有进行交换
            Swap(num,1,i);                            //交换函数  交换num[j-1]和num[j]的值
            HeapAdjust(num,1,i-1);
        }
    }
    /*本函数是为了将num调整为一个大顶堆，num除了num【1】以外，
    其他节点都符合大顶堆的定义，这个函数是为堆排序算法服务的*/
    public static void HeapAdjust(int[] num,int start,int stop){            
        int i, num_x;
        num_x = num[start];
        for(i = 2*start; i <= stop; i*=2){       //沿关键字较大的纪录项下筛选
            if(i+1 >= num.length){                //没有右孩子节点时，单独判断，否则num[i+1]会越界
                if(num[i/2] < num[i]){
                    num[i/2] = num[i];
                    start = i;
                 break;
              }else{
                  break;
              }
            }
            if(num[i] < num[i+1] && i < stop){
                ++i;                        //i为关键字较大的记录的下标 
            }
            if(num_x >= num[i]){                 //不在向下找了，num_x已经是最大的了
                break;
            }
            num[start] = num[i];
            start = i;
        }
        num[start] = num_x;
    }


    //归并排序
    public static void MergeSort(int[] num){
        int[] temp =new int[num.length];
        MSort(num,temp ,1,num.length-1);
    }
    //Msort函数是将list数组进行分割，Merge函数是将分割后的list数组进行排序在组合
    public static void MSort(int[] list ,int[] temp,int left,int right){
        if(left  == right){
            return;   
        }else{
            int m = (left + right) / 2;
            MSort(list,temp,left,m);
            MSort(list,temp,m+1,right);
            Merge(list,temp,left,m+1,right);
        }
    }
    public static void Merge(int[] list,int[] temp,int left,int mid,int right){
        int j = 0;
        int left_x = left;
        int mid_x = mid -1;
        int n = right - left +1;                        //当前temp数组中数的个数
        while(left <= mid_x &&  mid <= right){              //左右数组第一个数进行比较  把较小的数如到temp数组中
            if(list[left] < list[mid]){
                temp[j++] = list[left++];
            }else{
                temp[j++] = list[mid++];
            }
        }
        while(left <= mid_x){                         //如果左边的数比右边的数多，就将剩下的入到temp数组中    j
            temp[j++] = list[left++];
        }

        while(mid <= right){                           //如果右边打数比左边的数多，就将右边剩下的数加入到temp数组当中去
            temp[j++] = list[mid++];
        }
        
        for(j = 0; j < n; j++){             //   将得到的temp数组加到list数组中    
            list[left_x+j] = temp[j];
        }         
    }

    //快速排序
    public static void QuickSort(int[] num){
        QSort(num,1,num.length-1);
    }
    public static void QSort(int[] num, int left, int right){
        int mid = Partition(num,left,right);

        QSort(num,left,mid-1);
        QSort(num,mid+1,right); 
    }
    //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
    public static int   Partition(int[] num, int left, int right){
        int result;
        result = num[left];
        while(left < right){
            while( left < right && num[right] > result){
                right++;
            }
            Swap(num,left,right);
            while( left < right && num[left] < result){
                left++;
            }
            Swap(num,left,right);
        }
        return left;
    }

    //快速排序优化
    public static void QuickSort_Op(int[] num){
        Qsort_Op(num,1,num.length-1);
    }
    public static void Qsort_Op(int[] num, int left, int right){
        final int N = 7;                //数组长度的阀值  当数组长度低于这个长度是就不在使用快速排序，而是使用插入排序
        if((right-left) > N){
            //尾递归优化
            while(left < right){
                int mid = Partition_Op(num,left,right);
        
                Qsort_Op(num, left, mid-1);        //对底子表进行递归排序
                left = mid;            //尾递归
            }
         }else{              //当right-left小于7时，用直接插入排序
               InsertSort(num);  
         }
   }
  //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
    public static int Partition_Op(int[] num, int left, int right){
        int result;

        //优化选取轴承    三数取中（取左端、右端，中间三个），进行排序，取中间数作为轴承
        int m = left + (right - left);
        if(num[left] > num[right]){
            Swap(num,left,right);
        }
        if(num[m] > num[right]){
            Swap(num,m,right);
        }
        if(num[left] < num[m]){
            Swap(num,left,m);
        }
        result  = num[left];         //y用子表的第一个记录作为轴承记录
        num[0] = result;            //将轴承关键字备份到num[0]
        while( left < right ){
            while(left < right && num[right] > result){
                right--;
            }
            num[left] = num[right];  //选择替换而不是交换方式进行
            while(left < right && num[left] < result){
                left++;
            }
            num[right] = num[left];         //选择替换而不是交换方式进行操作
        }
        num[left] = num[0];
        return left;
    }

}