数据结构各种排序算法及其java程序实现

各种排序算法：冒择路(入)兮(稀)快归堆，桶式排序，基数排序

冒泡排序，选择排序，插入排序，稀尔排序，快速排序，归并排序，堆排序，桶式排序，基数排序

一、冒泡排序(BubbleSort)
1. 基本思想：
　　两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
2. 排序过程：
　　设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
【示例】：
49 13 13 13 13 13 13 13 
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97

java代码实现：

 /**
 * 冒泡排序：执行完一次内for循环后，最小的一个数放到了数组的最前面（跟那一个排序算法* 不一样）。相邻位置之间交换
 */

 public class BubbleSort {

     /**
      * 排序算法的实现，对数组中指定的元素进行排序
      * @param array 待排序的数组
      * @param from 从哪里开始排序
      * @param end 排到哪里
      * @param c 比较器
      */
     public void bubble(Integer[] array, int from, int end) {
         //需array.length - 1轮比较
         for (int k = 1; k < end - from + 1; k++) {
             //每轮循环中从最后一个元素开始向前起泡，直到i=k止，即i等于轮次止
             for (int i = end - from; i >= k; i--) {
                 //按照一种规则（后面元素不能小于前面元素）排序
                 if ((array[i].compareTo(array[i - 1])) < 0) {
                     //如果后面元素小于了（当然是大于还是小于要看比较器实现了）前面的元素，则前后交换
                     swap(array, i, i - 1);
                 }
             }
         }
     }

     /**
      * 交换数组中的两个元素的位置
      * @param array 待交换的数组
      * @param i 第一个元素
      * @param j 第二个元素
      */
     public void swap(Integer[] array, int i, int j) {
         if (i != j) {//只有不是同一位置时才需交换
             Integer tmp = array[i];
             array[i] = array[j];
             array[j] = tmp;
         }
     }


     /**
     * 测试
     * @param args
     */
     public static void main(String[] args) {
         Integer[] intgArr = { 7, 2, 4, 3, 12, 1, 9, 6, 8, 5, 11, 10 };
         BubbleSort bubblesort = new BubbleSort();
         bubblesort.bubble(intgArr,0,intgArr.length-1);
         for(Integer intObj:intgArr){
             System.out.print(intObj + " ");
         }
     }
 }

另外一种实现方式：

 /**
 冒泡排序：执行完一次内for循环后，最大的一个数放到了数组的最后面。相邻位置之间交换
 */
 public class BubbleSort2{
     public static void main(String[] args){
         int[] a = {3,5,9,4,7,8,6,1,2};
         BubbleSort2 bubble = new BubbleSort2();
         bubble.bubble(a);
         for(int num:a){
             System.out.print(num + " ");
         }
     }

     public void bubble(int[] a){
         for(int i=a.length-1;i>0;i--){
             for(int j=0;j<i;j++){
                 if(new Integer(a[j]).compareTo(new Integer(a[j+1]))>0){
                     swap(a,j,j+1);
                 }
             }
         }
     }

     public void swap(int[] a,int x,int y){
         int temp;
         temp=a[x];
         a[x]=a[y];
         a[y]=temp;
     }
 }

 

二、选择排序
1. 基本思想：
　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
2. 排序过程：
【示例】：
  初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 ［38 65 97 76 49 27 49]
第二趟排序后 13 27 ［65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [49 97 65 76]
第五趟排序后 13 27 38 49 49 [97 97 76]
第六趟排序后 13 27 38 49 49 76 [76 97]
第七趟排序后 13 27 38 49 49 76 76 [ 97]
最后排序结果 13 27 38 49 49 76 76 97

java代码实现：

 /**
 * 简单选择排序：执行完一次内for循环后最小的一个数放在了数组的最前面。
 */
 public class SelectSort {

     /**
      * 排序算法的实现，对数组中指定的元素进行排序
      * @param array 待排序的数组
      * @param from 从哪里开始排序
      * @param end 排到哪里
      * @param c 比较器
      */
     public void select(Integer[] array) {
         int minIndex;//最小索引
         /*
          * 循环整个数组（其实这里的上界为 array.length - 1 即可，因为当 i= array.length-1
          * 时，最后一个元素就已是最大的了，如果为array.length时，内层循环将不再循环），每轮假设
          * 第一个元素为最小元素，如果从第一元素后能选出比第一个元素更小元素，则让让最小元素与第一
          * 个元素交换
          */
         for (int i=0; i<array.length; i++) {
             minIndex = i;//假设每轮第一个元素为最小元素
             //从假设的最小元素的下一元素开始循环
             for (int j=i+1;j<array.length; j++) {
                 //如果发现有比当前array[smallIndex]更小元素，则记下该元素的索引于smallIndex中
                 if ((array[j].compareTo(array[minIndex])) < 0) {
                     minIndex = j;
                 }
             }

             //先前只是记录最小元素索引，当最小元素索引确定后，再与每轮的第一个元素交换
             swap(array, i, minIndex);
         }
     }

     public static void swap(Integer[] intgArr,int x,int y){
         //Integer temp; //这个也行
         int temp;
         temp=intgArr[x];
         intgArr[x]=intgArr[y];
         intgArr[y]=temp;
     }

     /**
      * 测试
      * @param args
      */
     public static void main(String[] args) {
         Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7 };
         SelectSort insertSort = new SelectSort();
         insertSort.select(intgArr);
         for(Integer intObj:intgArr){
             System.out.print(intObj + " ");
         }

     }
 }

 

三、插入排序(Insertion Sort)
1. 基本思想：
  每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
2. 排序过程：　 
【示例】：
[初始关键字] [49] 38 65 97 76 13 27 49
    J=2(38) [38 49] 65 97 76 13 27 49
    J=3(65) [38 49 65] 97 76 13 27 49
    J=4(97) [38 49 65 97] 76 13 27 49
    J=5(76) [38 49 65 76 97] 13 27 49
    J=6(13) [13 38 49 65 76 97] 27 49
    J=7(27) [13 27 38 49 65 76 97] 49
    J=8(49) [13 27 38 49 49 65 76 97] 

java代码实现：

 /**
 * 直接插入排序：
 * 注意所有排序都是从小到大排。
 */

 public class InsertSort {

     /**
      * 排序算法的实现，对数组中指定的元素进行排序
      * @param array 待排序的数组
      * @param from 从哪里开始排序
      * @param end 排到哪里
      * @param c 比较器
      */
     public void insert(Integer[] array, int from, int end) {

         /*
          * 第一层循环：对待插入（排序）的元素进行循环
          * 从待排序数组断的第二个元素开始循环，到最后一个元素（包括）止
          */
         for (int i=from+1; i<=end; i++) {
             /*
              * 第二层循环：对有序数组进行循环，且从有序数组最第一个元素开始向后循环
              * 找到第一个大于待插入的元素
              * 有序数组初始元素只有一个，且为源数组的第一个元素，一个元素数组总是有序的
              */
             for (int j = 0; j < i; j++) {
                 Integer insertedElem = array[i];//待插入到有序数组的元素
                 //从有序数组中最一个元素开始查找第一个大于待插入的元素
                 if ((array[j].compareTo(insertedElem)) > 0) {
                     //找到插入点后，从插入点开始向后所有元素后移一位
                     move(array, j, i - 1);
                     //将待排序元素插入到有序数组中
                     array[j] = insertedElem;
                     break;
                 }
             }
         }

         //=======以下是java.util.Arrays的插入排序算法的实现
         /*
          * 该算法看起来比较简洁一j点，有点像冒泡算法。
          * 将数组逻辑上分成前后两个集合，前面的集合是已经排序好序的元素，而后面集合为待排序的
          * 集合，每次内层循从后面集合中拿出一个元素，通过冒泡的形式，从前面集合最后一个元素开
          * 始往前比较，如果发现前面元素大于后面元素，则交换，否则循环退出
          *
          * 总感觉这种算术有点怪怪，既然是插入排序，应该是先找到插入点，而后再将待排序的元素插
          * 入到的插入点上，那么其他元素就必然向后移，感觉算法与排序名称不匹，但返过来与上面实
          * 现比，其实是一样的，只是上面先找插入点，待找到后一次性将大的元素向后移，而该算法却
          * 是走一步看一步，一步一步将待排序元素往前移
          */
         /*
         for (int i = from; i <= end; i++) {
             for (int j = i; j > from && c.compare(array[j - 1], array[j]) > 0; j--) {
                 swap(array, j, j - 1);
             }
         }
         */
     }


      /**
      * 数组元素后移
      * @param array 待移动的数组
      * @param startIndex 从哪个开始移
      * @param endIndex 到哪个元素止
      */
     public void move(Integer[] array, int startIndex, int endIndex) {
         for (int i = endIndex; i >= startIndex; i--) {
             array[i+1] = array[i];
         }
     }


     /**
      * 测试
      * @param args
      */
     public static void main(String[] args) {
         Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7 };
         InsertSort insertSort = new InsertSort();
         insertSort.insert(intgArr,0,intgArr.length-1);
         for(Integer intObj:intgArr){
             System.out.print(intObj + " ");
         }
     }
 }

 

四、稀尔排序

java代码实现：

 /**
 * 插入排序----希尔排序：我们选择步长为：15,7,3,1
 * 我们选择步长公式为：2^k-1,2^(k-1)-1,……,15,7,3,1     (2^4-1,2^3-1,2^2-1,2^1-1)
 * 注意所有排序都是从小到大排。
 */
 public class ShellSort {

     /**
      * 排序算法的实现，对数组中指定的元素进行排序
      * @param array 待排序的数组
      * @param from 从哪里开始排序
      * @param end 排到哪里
      * @param c 比较器
      */
     public void sort(Integer[] array, int from, int end) {
         //初始步长，实质为每轮的分组数
         int step = initialStep(end - from + 1);

         //第一层循环是对排序轮次进行循环。(step + 1) / 2 - 1 为下一轮步长值
         for (; step >= 1; step = (step + 1) / 2 - 1) {
             //对每轮里的每个分组进行循环
             for (int groupIndex = 0; groupIndex < step; groupIndex++) {

                 //对每组进行直接插入排序
                 insertSort(array, groupIndex, step, end);
             }
         }
     }

     /**
      * 直接插入排序实现
      * @param array 待排序数组
      * @param groupIndex 对每轮的哪一组进行排序
      * @param step 步长
      * @param end 整个数组要排哪个元素止
      * @param c 比较器
      */
     public void insertSort(Integer[] array, int groupIndex, int step, int end) {
         int startIndex = groupIndex;//从哪里开始排序
         int endIndex = startIndex;//排到哪里
         /*
          * 排到哪里需要计算得到，从开始排序元素开始，以step步长，可求得下元素是否在数组范围内，
          * 如果在数组范围内，则继续循环，直到索引超现数组范围
          */
         while ((endIndex + step) <= end) {
             endIndex += step;
         }

         // i为每小组里的第二个元素开始
         for (int i = groupIndex + step; i <= end; i += step) {
             for (int j = groupIndex; j < i; j += step) {
                 Integer insertedElem = array[i];
                 //从有序数组中最一个元素开始查找第一个大于待插入的元素
                 if ((array[j].compareTo(insertedElem)) >= 0) {
                     //找到插入点后，从插入点开始向后所有元素后移一位
                     move(array, j, i - step, step);
                     array[j] = insertedElem;
                     break;
                 }
             }
         }
     }

     /**
      * 根据数组长度求初始步长
      *
      * 我们选择步长的公式为：2^k-1,2^(k-1)-1,...,15,7,3,1 ，其中2^k 减一即为该步长序列，k
      * 为排序轮次
      *
      * 初始步长：step = 2^k-1
      * 初始步长约束条件：step < len - 1 初始步长的值要小于数组长度还要减一的值（因
      * 为第一轮分组时尽量不要分为一组，除非数组本身的长度就小于等于4）
      *
      * 由上面两个关系试可以得知：2^k - 1 < len - 1 关系式，其中k为轮次，如果把 2^k 表 达式
      * 转换成 step 表达式，则 2^k-1 可使用 (step + 1)*2-1 替换（因为 step+1 相当于第k-1
      * 轮的步长，所以在 step+1 基础上乘以 2 就相当于 2^k 了），即步长与数组长度的关系不等式为
      * (step + 1)*2 - 1 < len -1
      *
      * @param len 数组长度
      * @return
      */
     public static int initialStep(int len) {
         /*
          * 初始值设置为步长公式中的最小步长，从最小步长推导出最长初始步长值，即按照以下公式来推:
          * 1,3,7,15,...,2^(k-1)-1,2^k-1
          * 如果数组长度小于等于4时，步长为1，即长度小于等于4的数组不用分组，此时直接退化为直接插入排序
          */
         int step = 1;

         //试探下一个步长是否满足条件，如果满足条件，则步长置为下一步长
         while ((step + 1) * 2 - 1 < len - 1) {
             step = (step + 1) * 2 - 1;
         }

         System.out.println("初始步长 : " + step);
         return step;
     }

     /**
      * 以指定的步长将数组元素后移，步长指定每个元素间的间隔
      * @param array 待排序数组
      * @param startIndex 从哪里开始移
      * @param endIndex 到哪个元素止
      * @param step 步长
      */
     protected final void move(Integer[] array, int startIndex, int endIndex, int step)  {
         for (int i = endIndex; i >= startIndex; i -= step) {
             array[i + step] = array[i];
         }
     }


     /**
      * 测试
      * @param args
      */
     public static void main(String[] args) {
         Integer[] intgArr = { 5, 9, 1, 4, 8, 2, 6, 3, 7, 0 };
         ShellSort shellSort = new ShellSort();
         shellSort.sort(intgArr,0,intgArr.length-1);
         for(Integer intObj:intgArr){
             System.out.print(intObj + " ");
         }
     }
 }

 

五、快速排序（Quick Sort）
1. 基本思想：
　　在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。
2. 排序过程：
【示例】：

初始关键字 ［49 38 65 97 76 13 27 49］
一趟排序之后 ［27 38 13］ 49 ［76 97 65 49］ 
二趟排序之后 ［13］ 27 ［38］ 49 ［49 65］76 ［97］
三趟排序之后 13 27 38 49 49 ［65］76 97
最后的排序结果 13 27 38 49 49 65 76 97 
各趟排序之后的状态

java代码实现：

 /**
 * 快速排序：
 */

 public class QuickSort {

     /**
      * 排序算法的实现，对数组中指定的元素进行排序
      * @param array 待排序的数组
      * @param from 从哪里开始排序
      * @param end 排到哪里
      * @param c 比较器
      */
     //定义了一个这样的公有方法sort，在这个方法体里面执行私有方法quckSort（这种方式值得借鉴）。
     public void sort(Integer[] array, int from, int end) {
         quickSort(array, from, end);
     }

     /**
      * 递归快速排序实现
      * @param array 待排序数组
      * @param low 低指针
      * @param high 高指针
      * @param c 比较器
      */
     private void quickSort(Integer[] array, int low, int high) {
         /*
          * 如果分区中的低指针小于高指针时循环；如果low=higth说明数组只有一个元素，无需再处理；
          * 如果low > higth，则说明上次枢纽元素的位置pivot就是low或者是higth，此种情况
          * 下分区不存，也不需处理
          */
         if (low < high) {
             //对分区进行排序整理

             //int pivot = partition1(array, low, high);
             int pivot = partition2(array, low, high);
             //int pivot = partition3(array, low, high);

             /*
              * 以pivot为边界，把数组分成三部分[low, pivot - 1]、[pivot]、[pivot + 1, high]
              * 其中[pivot]为枢纽元素，不需处理，再对[low, pivot - 1]与[pivot + 1, high]
              * 各自进行分区排序整理与进一步分区
              */
             quickSort(array, low, pivot - 1);
             quickSort(array, pivot + 1, high);
         }

     }

     /**
      * 实现一
      *
      * @param array 待排序数组
      * @param low 低指针
      * @param high 高指针
      * @param c 比较器
      * @return int 调整后中枢位置
      */
     private int partition1(Integer[] array, int low, int high) {
         Integer pivotElem = array[low];//以第一个元素为中枢元素
         //从前向后依次指向比中枢元素小的元素，刚开始时指向中枢，也是小于与大小中枢的元素的分界点
         int border = low;

         /*
          * 在中枢元素后面的元素中查找小于中枢元素的所有元素，并依次从第二个位置从前往后存放
          * 注，这里最好使用i来移动，如果直接移动low的话，最后不知道数组的边界了，但后面需要
          * 知道数组的边界
          */
         for (int i = low + 1; i <= high; i++) {
             //如果找到一个比中枢元素小的元素
             if ((array[i].compareTo(pivotElem)) < 0) {
                 swap(array, ++border, i);//border前移，表示有小于中枢元素的元素
             }
         }
         /*
          * 如果border没有移动时说明说明后面的元素都比中枢元素要大，border与low相等，此时是
          * 同一位置交换，是否交换都没关系；当border移到了high时说明所有元素都小于中枢元素，此
          * 时将中枢元素与最后一个元素交换即可，即low与high进行交换，大的中枢元素移到了 序列最
          * 后；如果 low <minIndex< high，表 明中枢后面的元素前部分小于中枢元素，而后部分大于
          * 中枢元素，此时中枢元素与前部分数组中最后一个小于它的元素交换位置，使得中枢元素放置在
          * 正确的位置
          */
         swap(array, border, low);
         return border;
     }

     /**
      * 实现二
      *
      * @param array 待排序数组
      * @param low 待排序区低指针
      * @param high 待排序区高指针
      * @param c 比较器
      * @return int 调整后中枢位置
      */
     private int partition2(Integer[] array, int low, int high) {
         int pivot = low;//中枢元素位置，我们以第一个元素为中枢元素
         //退出条件这里只可能是 low = high
         while (true) {
             if (pivot != high) {//如果中枢元素在低指针位置时，我们移动高指针
                 //如果高指针元素小于中枢元素时，则与中枢元素交换
                 if ((array[high].compareTo(array[pivot])) < 0) {
                     swap(array, high, pivot);
                     //交换后中枢元素在高指针位置了
                     pivot = high;
                 } else {//如果未找到小于中枢元素，则高指针前移继续找
                     high--;
                 }
             } else {//否则中枢元素在高指针位置
                 //如果低指针元素大于中枢元素时，则与中枢元素交换
                 if ((array[low].compareTo(array[pivot])) > 0) {
                     swap(array, low, pivot);
                     //交换后中枢元素在低指针位置了
                     pivot = low;
                 } else {//如果未找到大于中枢元素，则低指针后移继续找
                     low++;
                 }
             }
             if (low == high) {
                 break;
             }
         }
         //返回中枢元素所在位置，以便下次分区
         return pivot;
     }

     /**
      * 实现三
      *
      * @param array 待排序数组
      * @param low 待排序区低指针
      * @param high 待排序区高指针
      * @param c 比较器
      * @return int 调整后中枢位置
      */
     private int partition3(Integer[] array, int low, int high) {
         int pivot = low;//中枢元素位置，我们以第一个元素为中枢元素
         low++;
         //----调整高低指针所指向的元素顺序，把小于中枢元素的移到前部分，大于中枢元素的移到后面部分
         //退出条件这里只可能是 low = high

         while (true) {
             //如果高指针未超出低指针
             while (low < high) {
                 //如果低指针指向的元素大于或等于中枢元素时表示找到了，退出，注：等于时也要后移
                 if ((array[low].compareTo(array[pivot])) >= 0) {
                     break;
                 } else {//如果低指针指向的元素小于中枢元素时继续找
                     low++;
                 }
             }

             while (high > low) {
                 //如果高指针指向的元素小于中枢元素时表示找到，退出
                 if ((array[high].compareTo(array[pivot])) < 0) {
                     break;
                 } else {//如果高指针指向的元素大于中枢元素时继续找
                     high--;
                 }
             }
             //退出上面循环时 low = high
             if (low == high) {
                 break;
             }

             swap(array, low, high);
         }

         //----高低指针所指向的元素排序完成后，还得要把中枢元素放到适当的位置
         if ((array[pivot].compareTo(array[low])) > 0) {
             //如果退出循环时中枢元素大于了低指针或高指针元素时，中枢元素需与low元素交换
             swap(array, low, pivot);
             pivot = low;
         } else if ((array[pivot].compareTo(array[low])) <= 0) {
             swap(array, low - 1, pivot);
             pivot = low - 1;
         }

         //返回中枢元素所在位置，以便下次分区
         return pivot;
     }

         /**
      * 交换数组中的两个元素的位置
      * @param array 待交换的数组
      * @param i 第一个元素
      * @param j 第二个元素
      */
     public void swap(Integer[] array, int i, int j) {
         if (i != j) {//只有不是同一位置时才需交换
             Integer tmp = array[i];
             array[i] = array[j];
             array[j] = tmp;
         }
     }

     /**
     * 测试
     * @param args
     */
     public static void main(String[] args) {
         Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7 };
         QuickSort quicksort = new QuickSort();
         quicksort.sort(intgArr,0,intgArr.length-1);
         for(Integer intObj:intgArr){
             System.out.print(intObj + " ");
         }
     }
 }

 

六、归并排序

java代码实现：

 /**
 归并排序：里面是一个递归程序，深刻理解之。
 */
 public class MergeSort{

     /**
      * 递归划分数组
      * @param arr
      * @param from
      * @param end
      * @param c void
      */
     public void partition(Integer[] arr, int from, int end) {