Java排序算法（二）

java排序算法（二）

二、改进排序算法

2.1希尔排序

定义：希尔排序(ShellSort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

常用的h序列（增量）由Knuth提出，该序列从1开始，通过如下公式产生：h = 3 * h +1

反过来程序需要反向计算h序列，应该使用h=(h-1)/3

2.2快速排序

定义：快速排序（Quicksort）是对冒泡排序的一种改进，是一种非稳定排序。

快速排序通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2.3归并排序

定义：归并排序（MergeSort）是建立在归并操作上的一种有效的排序算法，该算法是分治法的典型应用。是稳定排序。

归并排序假设初始序列（数据）有n个记录，看作n个子序列，每个子序列长度为一，然后进行两两归并，得到n/2个长度为2的子序列；让后再两两归并，...，重复操作，最后得到一个长度为n的有序序列，这种方法称为2路归并排序。

代码如下

 public class Sort
 {
     //实现从小到大排序
     public static void main(String[] args)
     {
         int[] arr1 = {9,1,5,8,3,7,4,6,2};
         //quickSort(arr1,0,8);
         mergeSort(arr1);
         //shellSort(arr1);
         for(int i=0;i<arr1.length;i++)
         {
             System.out.println(arr1[i]);
         }
     }
     /*---------------------------------希尔排序---------------------------------------------
     *希尔排序（缩小增量排序）,对直接插入排序的改进
     *通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而使数据项大框度的移动
     *当这些数据项排过一趟序之后，希尔排序算法见效数据项的间隔再进行排序，依次进行下去
     *哦爱心时的数据项之间的间隔被称为增量，习惯上用h表示
     *常用h序列由Knuth剔除，序列从1开始，通过公式产生h=3*h+1；
     *反过来程序反向计算h=（h-1）/3
     ---------------------------------------------------------------------------------------*/
     public static void shellSort(int[] data)
     {
         int h=1;
         while(h<=data.length/3)
         {
             h=h*3+1;
         }
         while(h>0)
         {
             for (int i = h; i < data.length; i += h)
             {
                 if (data[i] < data[i - h])
                 {
                     int tmp = data[i];
                     int j = i - h;
                     while (j >= 0 && data[j] > tmp)
                     {
                         data[j + h] = data[j];
                         j -= h;
                     }
                     data[j + h] = tmp;
                     //print(data);
                 }
             }
             // 计算出下一个h值(增量)
             h = (h - 1) / 3;
         }
     }
     /*---------------------------------快速排序---------------------------------------------
     -----------------------------------------------------------------------------------*/
     public static void quickSort(int[] arr,int low,int high)
     {
         if(low<high)
         {
             int mid = getMid(arr,low,high);
             quickSort(arr,0,mid-1);        //递归排序
             quickSort(arr,mid+1,high);
         }
     }
     //取中值
     public static int getMid(int[] arr,int low,int high)
     {
         int key = arr[low];                //基准元素
         while(low<high)
         {
             while(low<high&&arr[high]>=key)    //从high开始找比基准小的元素，如果找到，则互换位置
             {
                 high--;
             }
             arr[low] = arr[high];
             while(high>low&&arr[low]<=key)    //从low开始找比基准大的，放到之前high空出的位置上
             {
                 low++;
             }
             arr[high]=arr[low];
         }
         arr[low]=key;                //此时low=high是基准元素的位置，也是空出来的那个位置
         return low;
     }

     /*--------------------------------归并排序------------------------------------
     -------------------------------------------------------------------------------*/
     public static void mergeSort(int[] data)
     {
         sort(data,0,data.length-1);
     }
     public static void sort(int[] data,int left,int right)
     {
         if(left>=right)
         {
             return;
         }
         int center = (left + right) / 2;          // 找出中间索引
         sort(data, left, center);                // 对左边数组进行递归
         sort(data, center + 1, right);          // 对右边数组进行递归
         merge(data, left, center, right);       // 合并
     }
      /**
      * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
      *
      * @param data        数组对象
      * @param left        左数组的第一个元素的索引
      * @param center    左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
      * @param right        右数组最后一个元素的索引
      */
     public static void merge(int[] data, int left, int center, int right) {
         // 临时数组
         int[] tmpArr = new int[data.length];
         // 右数组第一个元素索引
         int mid = center + 1;
         // third 记录临时数组的索引
         int third = left;
         // 缓存左数组第一个元素的索引
         int tmp = left;
         while (left <= center && mid <= right) {
             // 从两个数组中取出最小的放入临时数组
             if (data[left] <= data[mid]) {
                 tmpArr[third++] = data[left++];
             } else {
                 tmpArr[third++] = data[mid++];
             }
         }
         // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
         while (mid <= right) {
             tmpArr[third++] = data[mid++];
         }
         while (left <= center) {
             tmpArr[third++] = data[left++];
         }
         // 将临时数组中的内容拷贝回原数组中
         // （原left-right范围的内容被复制回原数组）
         while (tmp <= right) {
             data[tmp] = tmpArr[tmp++];
         }
     }
 }