程序博客网 > 企业版支付宝申请淘宝

排 序

来源：互联网 发布：企业版支付宝申请淘宝 编辑：程序博客网 时间：2024/04/29 09:19

1. 排序的分类

    在介绍有关排序的算法之前，先来介绍与排序相关的基本概念。本节主要介绍排序的基本概念及相关概念。
排序：把一个无序的元素序列按照元素的关键字递增或递减排列为有序的序列。

  • 稳定排序和不稳定排序：在排列过程中，如果存在两个关键字相等即ki=kj(1≤i≤n,1≤j≤n,i≠j)，在排序前对应的元素Ei在Ej之前。
  • 内排序和外排序：根据排序过程中，所利用的内存储器和外存储器的情况，将排序分为两类：内部排序和外部排序。
  • 内排序的方法：按照排序过程中采用的策略将排序分为几个大类：插入排序、选择排序、交换排序和归并排序。这些排序方法各有优点和不足，在使用时，可根据具体情况选择比较合适的方法。

    排序分类如下所示：

（1）插入排序（直接插入排序、折半插入排序、希尔排序）；
（2）交换排序（冒泡泡排序、快速排序）；
（3）选择排序（直接选择排序、堆排序）；
（4）归并排序；
（5）基数排序。

 

2. 排序的比较

    比较各种排序算法的性能主要是考察各种排序算法的时间复杂度、空间复杂度和稳定性。

3. JAVA实现

 

（1）插入排序

    插入排序的算法思想是：在一个有序的元素序列中，不断地将新元素插入到该已经有序的元素列表中的合适位置，直到所有元素都插入到合适位置则完成排序。

<1> 直接插入排序

    直接插入排序的基本思想是：假设前i-1个元素已经有序，将第i个元素的关键字与前i-1个元素的关键字进行比较，找到合适的位置，将第i个元素插入。按照类似的方法，将剩下的元素依次插入到已经有序的序列中，完成插入排序。

 

示例代码：

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-3 下午12:40:02 
  5.  */  
  6. public class InsertSort implements Sort {  
  7.   
  8.     /* (non-Javadoc) 
  9.      * @see sort.Sort#sort(int[], java.lang.String) 
  10.      */  
  11.     @Override  
  12.     public int[] sortArray(int[] data, String sortType) {  
  13.         if(data == null || data.length == 0)  
  14.             return null;  
  15.         if (sortType.equals("asc")) { // 正排序，从小排到大  
  16.             // 比较的轮数  
  17.             for (int i = 1; i < data.length; i++) {  
  18.                 // 保证前i+1个数排好序  
  19.                 int temp = data[i];  
  20.                 int j;  
  21.                 for (j = i; j > 0 && data[j - 1] > temp; j--) {  
  22.                     data[j] = data[j - 1];  
  23.                 }  
  24.                 data[j] = temp;  
  25.             }  
  26.         } else if (sortType.equals("desc")) { // 倒排序，从大排到小  
  27.             // 比较的轮数  
  28.             for (int i = 1; i < data.length; i++) {  
  29.                 // 保证前i+1个数排好序  
  30.                 int temp = data[i];  
  31.                 int j;  
  32.                 for (j = i; j > 0 && data[j - 1] < temp; j--) {  
  33.                     data[j] = data[j - 1];  
  34.                 }  
  35.                 data[j] = temp;  
  36.             }  
  37.         } else {  
  38.             System.out.println("您输入的排序类型错误！");  
  39.         }  
  40.         return data;  
  41.     }  
  42.   
  43. }  

 

图 直接插入排序过程示意图

 

<2> 折半插入排序

    由于插入排序算法的基本思想是，将待排序元素插入到已经有序的元素序列的正确位置，因此，在查找正确插入位置时，可以采用折半查找的思想寻找插入位置。将这种插入排序称为折半插入排序。

 

示例代码：

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  * 
  4.  * Time: 2011-8-3 下午02:22:23 
  5.  */  
  6. public class BinInsertSort implements Sort {  
  7.   
  8.     /* (non-Javadoc) 
  9.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  10.      */  
  11.     @Override  
  12.     public int[] sortArray(int[] data, String sortType) {  
  13.         if(data == null || data.length == 0)     
  14.             return null;  
  15.         int low = 0,high = 0, mid = 0;  
  16.         if (sortType.equals("asc")) { // 正排序，从小排到大     
  17.             // 比较的轮数     
  18.             for (int i = 0; i < data.length -1; i++) {   /* 前i个元素已经有序，从第i+1个元素开始与前i个的有序的关键字比较 */  
  19.                 // 保证前i+1个数排好序     
  20.                 int temp = data[i+1];  
  21.                 low = 0;  
  22.                 high = i;  
  23.                 while(low <= high){                   /*利用折半查找思想寻找当前元素的合适位置 */  
  24.                     mid = (low + high) / 2;  
  25.                     if(data[mid] > temp)   
  26.                         high = mid - 1;  
  27.                     else  
  28.                         low = mid + 1;  
  29.                 }  
  30.                 int j;     
  31.                 for (j = i; j >= low; j--) {           /*移动元素，空出要插入的位置*/  
  32.                     data[j+1] = data[j];     
  33.                 }  
  34.                 data[low] = temp;                      /*将当前元素插入合适的位置*/  
  35.             }     
  36.         } else if (sortType.equals("desc")) { // 倒排序，从大排到小     
  37.             // 比较的轮数     
  38.             for (int i = 0; i < data.length -1; i++) {   /* 前i个元素已经有序，从第i+1个元素开始与前i个的有序的关键字比较 */  
  39.                 // 保证前i+1个数排好序     
  40.                 int temp = data[i+1];  
  41.                 low = 0;  
  42.                 high = i;  
  43.                 while(low <= high){                   /*利用折半查找思想寻找当前元素的合适位置 */  
  44.                     mid = (low + high) / 2;  
  45.                     if(data[mid] < temp)   
  46.                         high = mid - 1;  
  47.                     else  
  48.                         low = mid + 1;  
  49.                 }  
  50.                 int j;     
  51.                 for (j = i; j >= low; j--) {           /*移动元素，空出要插入的位置*/  
  52.                     data[j+1] = data[j];     
  53.                 }  
  54.                 data[low] = temp;                      /*将当前元素插入合适的位置*/  
  55.             }     
  56.         } else {     
  57.             System.out.println("您输入的排序类型错误！");     
  58.         }     
  59.         return data;    
  60.     }  
  61.   
  62. }  

 

<3> 希尔排序

    希尔排序也称为缩小增量排序，它的基本思想是：通过将待排序的元素分为若干个子序列，利用直接插入排序思想对子序列进行排序。然后将该子序列缩小，接着对子序列进行直接插入排序。按照这种思想，直到所有的元素都按照关键字有序排列。

示例代码：

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  * 
  4.  * Time: 2011-8-3 下午04:52:35 
  5.  */  
  6. public class ShellInsertSort implements Sort {  
  7.   
  8.     private int[] delta = {5,3,1};  
  9.     /* (non-Javadoc) 
  10.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  11.      */  
  12.     @Override  
  13.     public int[] sortArray(int[] data, String sortType) {  
  14.         /*希尔排序，每次调用算法ShellInsert,delta是存放增量的数组*/  
  15.         if(data == null || data.length == 0)     
  16.             return null;  
  17.         if(sortType.equals("asc")){  
  18.             for(int i=0; i<delta.length; i++){  
  19.                 shellInsertASC(data,delta[i]);  
  20.             }  
  21.         }  
  22.         else if(sortType.equals("desc")){  
  23.             for(int i=0; i<delta.length; i++){  
  24.                 shellInsertDESC(data,delta[i]);  
  25.             }  
  26.         }  
  27.         else{  
  28.             System.out.println("您输入的排序类型错误！");  
  29.         }  
  30.         return sortData;  
  31.     }  
  32.       
  33.     private int[] shellInsertASC(int[] data, int c){  
  34.         for(int i=c; i<data.length; i++){         /*将距离为c的元素作为一个子序列进行排序*/  
  35.             if(data[i] < data[i-c]){                /*如果后者小于前者，则需要移动元素*/  
  36.                 int temp = data[i];  
  37.                 int j;  
  38.                 for(j=i-c; j>=0 && data[j] > temp; j=j-c){  
  39.                     data[j+c] = data[j];  
  40.                 }  
  41.                 data[j+c] = temp;                   /*依次将元素插入到正确的位置*/  
  42.             }  
  43.         }  
  44.         return data;  
  45.     }  
  46.       
  47.     private int[] shellInsertDESC(int[] data, int c){  
  48.         for(int i=c; i<data.length; i++){         /*将距离为c的元素作为一个子序列进行排序*/  
  49.             if(data[i] > data[i-c]){                /*如果前者小于后者，则需要移动元素*/  
  50.                 int temp = data[i];  
  51.                 int j;  
  52.                 for(j=i-c; j>=0 && data[j] < temp; j=j-c){  
  53.                     data[j+c] = data[j];  
  54.                 }  
  55.                 data[j+c] = temp;                   /*依次将元素插入到正确的位置*/  
  56.             }  
  57.         }  
  58.         return data;  
  59.     }  
  60.   
  61. }  

 

图 希尔排序过程示意图

（2）交换排序

    交换排序的基本思想是：通过依次交换逆序的元素实现排序。 

<1> 冒泡排序

    冒泡排序的基本思想是：从第一个元素开始，依次比较两个相邻的元素，如果两个元素逆序，则进行交换，即如果L.data[i].key>L.data[i+1].key，则交换L.data[i]与L.data[i+1]。假设元素序列中有

n个待比较的元素，在第一趟排序结束，就会将元素序列中关键字最大的元素移到序列的末尾，即第n个位置。在第二趟排序结束，就会将关键字次大的元素移动到第n-1个位置。

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-3 下午06:38:15 
  5.  */  
  6. public class BubbleSort implements Sort {  
  7.   
  8.     /* 
  9.      * (non-Javadoc) 
  10.      *  
  11.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  12.      */  
  13.     @Override  
  14.     public int[] sortArray(int[] data, String sortType) {  
  15.         if (sortType.equals("asc")) { // 正排序，从小排到大  
  16.             // 比较的轮数  
  17.             for (int i = 1; i < data.length; i++) {  
  18.                 // 将相邻两个数进行比较，较大的数往后冒泡  
  19.                 for (int j = 0; j < data.length - i; j++) {  
  20.                     if (data[j] > data[j + 1]) {  
  21.                         // 交换相邻两个数  
  22.                         swap(data, j, j + 1);  
  23.                     }  
  24.                 }  
  25.             }  
  26.         } else if (sortType.equals("desc")) { // 倒排序，从大排到小  
  27.             // 比较的轮数  
  28.             for (int i = 1; i < data.length; i++) {  
  29.                 // 将相邻两个数进行比较，较大的数往后冒泡  
  30.                 for (int j = 0; j < data.length - i; j++) {  
  31.                     if (data[j] < data[j + 1]) {  
  32.                         // 交换相邻两个数  
  33.                         swap(data, j, j + 1);  
  34.                     }  
  35.                 }  
  36.             }  
  37.         } else {  
  38.             System.out.println("您输入的排序类型错误！");  
  39.         }  
  40.         return data;  
  41.     }  
  42.   
  43.     private void swap(int[] data, int x, int y) {  
  44.         int temp = data[x];  
  45.         data[x] = data[y];  
  46.         data[y] = temp;  
  47.     }  
  48.   
  49. }  

  

 

图 冒泡排序示意图

<2> 快速排序

    快速排序算法是冒泡排序的一种改进，与冒泡排序类似，只是快速排序是将元素序列中的关键字与指定的元素进行比较，将逆序的两个元素进行交换。快速排序的基本算法思想是：设待排序的元素序列的个数为n，分别存放在数组data[1…n]中，令第一元素作为枢轴元素，即将a[1]作为参考元素，令pivot=a[1]。

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-4 下午12:47:34 
  5.  */  
  6. public class QuickSort implements Sort {  
  7.   
  8.     /* 
  9.      * (non-Javadoc) 
  10.      *  
  11.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  12.      */  
  13.     @Override  
  14.     public int[] sortArray(int[] data, String sortType) {  
  15.         if (sortType.equals("asc")) { // 正排序，从小排到大  
  16.             qsort_asc(data, 0, data.length - 1);  
  17.         } else if (sortType.equals("desc")) { // 倒排序，从大排到小  
  18.             qsort_desc(data, 0, data.length - 1);  
  19.         } else {  
  20.             System.out.println("您输入的排序类型错误！");  
  21.         }  
  22.         return data;  
  23.     }  
  24.   
  25.     /** 
  26.      *  
  27.      * 快速排序的具体实现，排正序 
  28.      *  
  29.      * @param data 
  30.      * @param low 
  31.      * @param high 
  32.      */  
  33.   
  34.     private void qsort_asc(int data[], int low, int high) {  
  35.         int i, j, x;  
  36.         if (low < high) { // 这个条件用来结束递归  
  37.             i = low;  
  38.             j = high;  
  39.             x = data[i];  
  40.             while (i < j) {  
  41.                 while (i < j && data[j] > x) {  
  42.                     j--; // 从右向左找第一个小于x的数  
  43.                 }  
  44.                 if (i < j) {  
  45.                     data[i] = data[j];  
  46.                     i++;  
  47.                 }  
  48.                 while (i < j && data[i] < x) {  
  49.                     i++; // 从左向右找第一个大于x的数  
  50.                 }  
  51.                 if (i < j) {  
  52.                     data[j] = data[i];  
  53.                     j--;  
  54.                 }  
  55.             }  
  56.             data[i] = x;  
  57.             qsort_asc(data, low, i - 1);  
  58.             qsort_asc(data, i + 1, high);  
  59.         }  
  60.     }  
  61.   
  62.     /** 
  63.      *  
  64.      * 快速排序的具体实现，排倒序 
  65.      *  
  66.      * @param data 
  67.      * @param low 
  68.      * @param high 
  69.      */  
  70.   
  71.     private void qsort_desc(int data[], int low, int high) {  
  72.   
  73.         int i, j, x;  
  74.         if (low < high) { // 这个条件用来结束递归  
  75.             i = low;  
  76.             j = high;  
  77.             x = data[i];  
  78.             while (i < j) {  
  79.                 while (i < j && data[j] < x) {  
  80.                     j--; // 从右向左找第一个小于x的数  
  81.                 }  
  82.                 if (i < j) {  
  83.                     data[i] = data[j];  
  84.                     i++;  
  85.                 }  
  86.                 while (i < j && data[i] > x) {  
  87.                     i++; // 从左向右找第一个大于x的数  
  88.                 }  
  89.                 if (i < j) {  
  90.                     data[j] = data[i];  
  91.                     j--;  
  92.                 }  
  93.             }  
  94.             data[i] = x;  
  95.             qsort_desc(data, low, i - 1);  
  96.             qsort_desc(data, i + 1, high);  
  97.         }  
  98.     }  
  99. }  

 

图 快速排序过程示意图

（3）选择排序

    选择排序的基本思想是：从待排序的元素序列中选择关键字最小或最大的元素，将其放在已排序元素序列的最前面或最后面，其余的元素构成新的待排序元素序列，并从待排序元素序列中选择关键字最小的元素，将其放在已排序元素序列的最前面或最后面。 

<1> 简单选择排序

    简单选择排序的基本思想是：假设待排序的元素序列有n个，第一趟排序经过n-1次比较，从n个元素序列中选择关键字最小的元素，并将其放在元素序列的最前面即第一个位置。第二趟排序从剩余的n-1个元素中，经过n-2次比较选择关键字最小的元素，将其放在第二个位置。

 

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-4 下午04:48:52 
  5.  */  
  6. public class SelectSort implements Sort {  
  7.   
  8.     /* 
  9.      * (non-Javadoc) 
  10.      *  
  11.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  12.      */  
  13.     @Override  
  14.     public int[] sortArray(int[] data, String sortType) {  
  15.         if (sortType.equals("asc")) { // 正排序，从小排到大  
  16.             int index;  
  17.             for (int i = 1; i < data.length; i++) {  
  18.                 index = 0;  
  19.                 for (int j = 1; j <= data.length - i; j++) {  
  20.                     if (data[j] > data[index]) {  
  21.                         index = j;  
  22.                     }  
  23.                 }  
  24.                 // 交换在位置data.length-i和index(最大值)两个数  
  25.                 swap(data, data.length - i, index);  
  26.             }  
  27.         } else if (sortType.equals("desc")) { // 倒排序，从大排到小  
  28.             int index;  
  29.             for (int i = 1; i < data.length; i++) {  
  30.                 index = 0;  
  31.                 for (int j = 1; j <= data.length - i; j++) {  
  32.                     if (data[j] < data[index]) {  
  33.                         index = j;  
  34.                     }  
  35.                 }  
  36.                 // 交换在位置data.length-i和index(最大值)两个数  
  37.                 swap(data, data.length - i, index);  
  38.             }  
  39.         } else {  
  40.             System.out.println("您输入的排序类型错误！");  
  41.         }  
  42.         return data;  
  43.     }  
  44.   
  45.     private void swap(int[] data, int x, int y) {  
  46.         int temp = data[x];  
  47.         data[x] = data[y];  
  48.         data[y] = temp;  
  49.     }  
  50.   
  51. }  

 
 

图 简单选择排序过程示意图

<2> 堆排序

    n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)：
    (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ [n/2] )
    若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

    根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆。
    根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大根堆。
  注意：
    　①堆中任一子树亦是堆。
   　 ②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可定义k叉堆。
    堆排序(HeapSort)是一树形选择排序。
    堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系【参见二叉树的顺序存储结构】，在当前无序区中选择关键字最大(或最小)的记录。

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  * 
  4.  * Time: 2011-8-8 下午04:28:01 
  5.  */  
  6. public class HeapSort implements Sort {  
  7.   
  8.     /* (non-Javadoc) 
  9.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  10.      */  
  11.     @Override  
  12.     public int[] sortArray(int[] data, String sortType) {  
  13.         if(data == null || data.length == 0){  
  14.             return null;  
  15.         }  
  16.         if(sortType.equals("asc")){  
  17.             //该for循环用于创建一个堆，从n/2-1开始向前调整  
  18.             for(int i = data.length/2-1; i>=0; i--){//r.length/2-1为最后一个非终端节点，向前调整  
  19.                 adjustHeapASC(data,i,data.length);  
  20.             }     
  21.             //该for循环用于把堆顶元素和无序区的最后一个元素交换，成为有序区的第一个元素，并进行堆调整  
  22.             for(int j=data.length-1; j>0; j--){//每次调整出一个元素，则进行n-1趟排序  
  23.                 int temp = data[j];  
  24.                 data[j] = data[0];  
  25.                 data[0] = temp;  
  26.                 adjustHeapASC(data,0,j);  
  27.             }  
  28.         }  
  29.         else if(sortType.equals("desc")){  
  30.             //该for循环用于创建一个堆，从n/2-1开始向前调整  
  31.             for(int i = data.length/2-1; i>=0; i--){//r.length/2-1为最后一个非终端节点，向前调整  
  32.                 adjustHeapDESC(data,i,data.length);  
  33.             }     
  34.             //该for循环用于把堆顶元素和无序区的最后一个元素交换，成为有序区的第一个元素，并进行堆调整  
  35.             for(int j=data.length-1; j>0; j--){//每次调整出一个元素，则进行n-1趟排序  
  36.                 int temp = data[j];  
  37.                 data[j] = data[0];  
  38.                 data[0] = temp;  
  39.                 adjustHeapDESC(data,0,j);  
  40.             }  
  41.         }  
  42.         else{  
  43.             System.out.println("您输入的排序类型错误！");  
  44.         }  
  45.         return data;  
  46.     }  
  47.       
  48.     private void adjustHeapASC(int[] data,int s,int m){     
  49.         int temp = data[s];//暂存     
  50.         for(int j=2*s+1; j<m; j=j*2){     
  51.             if(j<m-1 && data[j]<data[j+1]){//找出这个根节点的两个子节点中的最大的     
  52.                 j++;    //j<m-1防止最后一个只有一个子节点，越界     
  53.             }     
  54.             if(temp > data[j]){//如果该元素已经是最大元素，则不用进行交换，直接跳出循环，自己与自己交换     
  55.                 break;     
  56.             }else{//否则，需要进行交换     
  57.                 data[s] = data[j];  
  58.                 s = j;//s被赋予新值，接着从该节点向下遍历子节点     
  59.             }     
  60.         }     
  61.         data[s] = temp;//一直找到大于或小于两个子节点的时候，把根节点放入该位置     
  62.     }  
  63.       
  64.     private void adjustHeapDESC(int[] data,int s,int m){     
  65.         int temp = data[s];//暂存     
  66.         for(int j=2*s+1; j<m; j=j*2){     
  67.             if(j<m-1 && data[j]>data[j+1]){//找出这个根节点的两个子节点中的最大的     
  68.                 j++;    //j<m-1防止最后一个只有一个子节点，越界     
  69.             }     
  70.             if(temp < data[j]){//如果该元素已经是最大元素，则不用进行交换，直接跳出循环，自己与自己交换     
  71.                 break;     
  72.             }else{//否则，需要进行交换     
  73.                 data[s] = data[j];  
  74.                 s = j;//s被赋予新值，接着从该节点向下遍历子节点     
  75.             }     
  76.         }     
  77.         data[s] = temp;//一直找到大于或小于两个子节点的时候，把根节点放入该位置     
  78.     }  
  79. }  

 

    堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。
    堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。
    由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。
    堆排序是就地排序，辅助空间为O(1)，
    它是不稳定的排序方法。

（4）归并排序

    归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。

    设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-8 下午05:49:49 
  5.  */  
  6. public class MergeSort implements Sort {  
  7.   
  8.     /* 
  9.      * (non-Javadoc) 
  10.      *  
  11.      * @see sort.Sort#sortArray(int[], java.lang.String) 
  12.      */  
  13.     @Override  
  14.     public int[] sortArray(int[] data, String sortType) {  
  15.         if(data == null || data.length == 0){  
  16.             return null;  
  17.         }  
  18.         gBSort(data,0,data.length-1,sortType);   
  19.         return data;  
  20.     }  
  21.       
  22.     private void gBSort(int[] data,int low,int high,String sortType){  
  23.         if(low<high){//区间长度大于1   
  24.             int m=(low+high)/2;     
  25.             gBSort(data,low,m,sortType);     
  26.             gBSort(data,m+1,high,sortType);  
  27.             if(sortType.equals("asc")){  
  28.                 mergeASC(data,data.length,low,m,high);  
  29.             }  
  30.             else if(sortType.equals("desc")){  
  31.                 mergeDESC(data,data.length,low,m,high);  
  32.             }  
  33.             else{  
  34.                 System.out.println("您输入的排序类型错误！");  
  35.             }  
  36.         }     
  37.     }  
  38.     private void mergeASC(int[] data, int tempSize, int low, int m, int high) {  
  39.         int i = low;  
  40.         int j = m + 1;  
  41.         int p = 0;  
  42.         int[] temp = new int[tempSize];// 动态创建临时的空间  
  43.         while (i <= m && j <= high) {  
  44.             temp[p++] = (data[i] < data[j]) ? data[i++] : data[j++];// 把小的放到temp中  
  45.         }  
  46.         while (i <= m) {  
  47.             temp[p++] = data[i++];// 把剩余的元素放到临时数组中  
  48.         }  
  49.         while (j <= high) {  
  50.             temp[p++] = data[j++];// 把剩余的元素放到临时数组中  
  51.         }  
  52.         for (int z = 0, x = low; x <= high; x++, z++) {  
  53.             data[x] = temp[z];// 把数组赋值给数组  
  54.         }  
  55.     }  
  56.       
  57.     private void mergeDESC(int[] data, int tempSize, int low, int m, int high) {  
  58.         int i = low;  
  59.         int j = m + 1;  
  60.         int p = 0;  
  61.         int[] temp = new int[tempSize];// 动态创建临时的空间  
  62.         while (i <= m && j <= high) {  
  63.             temp[p++] = (data[i] > data[j]) ? data[i++] : data[j++];// 把小的放到temp中  
  64.         }  
  65.         while (i <= m) {  
  66.             temp[p++] = data[i++];// 把剩余的元素放到临时数组中  
  67.         }  
  68.         while (j <= high) {  
  69.             temp[p++] = data[j++];// 把剩余的元素放到临时数组中  
  70.         }  
  71.         for (int z = 0, x = low; x <= high; x++, z++) {  
  72.             data[x] = temp[z];// 把数组赋值给数组  
  73.         }  
  74.     }  
  75.   
  76. }  

 

    归并排序是一种稳定的排序。可用顺序存储结构。也易于在链表上实现。对长度为n的文件，需进行 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。

（5）基数排序

    基数排序的基本思想是：从低位到高位依次对Kj(j=d-1，d-2，…，0)进行箱排序。在d趟箱排序中，所需的箱子数就是基数rd，这就是"基数排序"名称的由来。

 

    若排序文件不是以数组R形式给出，而是以单链表形式给出(此时称为链式的基数排序)，则可通过修改出队和人队函数使表示箱子的链队列无须分配结点空间，而使用原链表的结点空间。人队出队操作亦无需移动记录而仅需修改指针。虽然这样一来节省了一定的时间和空间，但算法要复杂得多，且时空复杂度就其数量级而言并未得到改观。
    基数排序的时间是线性的(即O(n))。
    基数排序所需的辅助存储空间为O(n+rd)。
    基数排序是稳定的。

补充代码：

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  * 
  4.  * Time: 2011-8-3 下午01:12:39 
  5.  */  
  6. public class SortContext {  
  7.     private Sort sort;  
  8.     /** 
  9.      * 初始化测试数组的方法 
  10.      *  
  11.      * @return 一个初始化好的数组 
  12.      */  
  13.     public int[] createArray() {  
  14.         Random random = new Random();  
  15.         int[] array = new int[10];  
  16.         for (int i = 0; i < 10; i++) {  
  17.             array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减，保证生成的数中有负数  
  18.         }  
  19.         System.out.println("==========原始序列==========");  
  20.         printArray(array);  
  21.         return array;  
  22.     }  
  23.   
  24.     /** 
  25.      *  
  26.      * 打印数组中的元素到控制台 
  27.      *  
  28.      * @param source 
  29.      */  
  30.   
  31.     public void printArray(int[] data) {  
  32.         for (int i : data) {  
  33.             System.out.print(i + ",");  
  34.         }  
  35.         System.out.println();  
  36.     }  
  37.       
  38.     /** 
  39.      * @return the sort 
  40.      */  
  41.     public Sort getSort() {  
  42.         return sort;  
  43.     }  
  44.   
  45.     /** 
  46.      * @param sort the sort to set 
  47.      */  
  48.     public void setSort(Sort sort) {  
  49.         this.sort = sort;  
  50.     }  
  51.       
  52.     public void sort(int[] data, String sortType){  
  53.         int[] sortData = sort.sortArray(data, sortType);  
  54.         printArray(sortData);  
  55.     }  
  56. }  

 

Java代码  收藏代码
  1. /** 
  2.  * @author jefferent@tom.com 
  3.  *  
  4.  *         Time: 2011-8-3 下午01:01:10 
  5.  */  
  6. public class SortTest {  
  7.       
  8.     public static void main(String[] args){  
  9.         SortContext test = new SortContext();  
  10.         int[] data = test.createArray();  
  11.           
  12.         test.setSort(new MergeSort());  
  13.         //test.setSort(new InsertSort());  
  14.         //test.setSort(new BinInsertSort());  
  15.         //test.setSort(new QuickSort());  
  16.         //test.setSort(new SelectSort());  
  17.         //test.setSort(new BubbleSort());  
  18.         test.sort(data, "asc");  
  19.         test.sort(data, "desc");  
  20.     }  
  21.   
  22. }  

 

企业版支付宝申请淘宝 企业版支付宝申请淘宝
原创粉丝点击
热门IT博客
票据打印软件票据打印软件
php微信支付代码php微信支付代码
阿里云备案幕布购买
云计算招聘岗位
淘宝模板制作教程 知乎
浪潮软件股票怎么样
日本mac口红价格
cd刻录机软件下载
php 发送一条udp消息
在线营业执照制作软件
java date 转换成秒
动画制作简单软件
公司软件打卡
mysql right syntax
软件说明书模板
淘宝店铺星级怎么算的
淘宝信用评价体系
u盘淘宝
淘宝店铺页头图片尺寸
海量数据分析
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 国际闲人之风云再起2 红楼之富贵闲人 质量单位有哪些 时间单位有哪些 面积单位有哪些 体积单位有哪些 闲发 闲妻多夫 闲妻 富贵闲妻 闲妻手记 闲妻当家 闲妻不可欺 农门闲妻 妻闲夫贵沈清微 侯门闲妻 妻闲夫贵 军宠闲妻 妻闲贵夫 莫惹农家小闲妻 妾本闲凉 闲妾 影留香 闲妾txt下载 闲居赋 秋日闲居 闲居姚合 闲居 文言文余闲居 二胡独奏闲居吟 闲居初夏午睡起阅读答案 闲庭信步 闲庭信步笑看云卷云舒 胜似闲庭信步 清穿之闲庭悠悠 闲看庭前花开花落 长生书闲庭 信步闲庭 荣辱不惊闲看庭前花开花落 长生 书闲庭 闲看庭前花开花落全诗 闲庭信步是什么意思

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里