常用排序小结

其实排序可分为两大类：内部排序和外部排序
 
内部排序：指需排序的记录存放在计算机随机存储器中进行的排序过程，也就是小数量的数据排序，像冒泡排序，选择排序等就是内部排序；
 
外部排序：指需排序的记录数量很大，以致内存一次不能容纳全部记录，在排序过程中需对外存进行访问的排序过程；这种我暂时没怎么接触过，不多说了；
 
下面是几种常见的部内排序方法：
1.       直接插入排序
每次从无序表中抽出一个数插入到有序表中，使得表仍然有序，第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 第二趟把第三个数据与前两个数从后向前扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程，整个过程如下：
假设序列为49  38  65  97  76  13  27
【初始关键字】                ( 49 )  38  65  97  13  27
 
     i=2          (38)          ( 38  49 )  65  97  13  27
 
     i=3          (65)          ( 38  49  65 )  97  13  27
 
     i=4          (97)          ( 38  49  65  97 )  13  27
 
     i=5          (13)          ( 13  38  49  65  97 )  27
 
     i=5          (27)          ( 13  27  38  49  65  97 )  
                    
                    监视哨（保存当前待比较的数值）temp
Java代码实现：
int[]  text(int[] a ){
   for (int i = 1; i < a.length; i++) {
　　int  temp = a[i];
　　for (int j = i; j > 0 && temp < a[j-1]; j--) {
　　a[j] = a[j - 1];
　　}
　　a[j] = temp;
}
return  a;
}
 
2．希尔排序
   又称缩小增量排序，其基本思想是：先将整个待排序的记录序列分割成若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序；
就是先取一个小于n（整个记录的长度）的整数t1作为第一个增量，把文件的全部记录分成t1个组。所有距离为t1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量t2<t1重复上述的分组和排序，直至所取的增量ti=1(ti<ti-l<…<t2<t1)，即所有记录放在同一组中进行直接插入排序为止；
如果记录的量大且一组内的记录相隔距离远，那么就可以省去多次数据交换，这就是对直接插入排序的改进之处。示例如下：
假设序列为：49  38  65  97  76  13  27  49  55  04
增量可取： 5 ， 3 ， 1
【初始关键字】 49  38  65  97  76  13  27  49  55  04
 先分成5组：（49  13） （38  27）  （65  49）  （97  55）  （76  04）          
 每一组进行直接插入排序后：13  27  49  55  04  49  38  65  97  76（第一趟排序结果）
 然后分成3组：（13  55  38  76） （27  04  65） （49  49  97）
每一组进行直接插入排序后：13  04  49  38  27  49  55  65  97  76（第二趟排序结果）
 再分成1组（对整个序列排序） （13  04  49  38  27  49  55  65  97  76）
 进行直接插入排序后：04  13  27  38  49  49  55  65  76  97（第三趟排序结果）
Java代码实现：
int []  ShellSort(int[] a) {
　　int  Temp; // 暂存变量
　　int  DataLength; // 分割集合的间隔长度
　　int  Pointer; // 进行处理的位置
DataLength = a.length / 2; // 初始集合间隔长度
　　while (DataLength != 0) // 数列仍可进行分割
{ // 对各个集合进行处理
　　for (int j = DataLength; j < a.length; j++) {
  　Temp = a[j]; // 暂存Data[j]的值,待交换值时用
　　Pointer = j - DataLength; // 计算进行处理的位置
// 进行集合内数值的比较与交换值
　　while (Temp < a[Pointer] && Pointer >= 0 && Pointer < a.length) {
　　a[Pointer + DataLength] = a[Pointer];
　　// 计算下一个欲进行处理的位置
　　Pointer = Pointer - DataLength;
　　if (Pointer < 0 || Pointer >= Index)
　　break;
　　}
　　// 与最后的数值交换
　　a[Pointer + DataLength] = Temp;
　　DataLength = DataLength / 2; // 计算下次分割的间隔长度
　　}
return  a;
}
3．冒泡排序
   冒泡排序的过程很简单，首先将第一个数和第二个数进行比较，如果是逆序的，就将两个数交换，然后比较第二个数和第三个数，依次类推，直到第n-1个数和第n个数据进行比较完为止，然后进行延续二趟排序，对前n-1个数进行同类操作，直到没有数可比；
假设序列为：  49  38  65  97  76  13  27  49
第一趟排序：38  49  65  76  13  27  49  97
第二趟排序：38  49  65  13  27  49  76
第三趟排序：38  49  13  27  49  65
第四趟排序：38  13  27  49  49
第五趟排序：13  27  38  49
第六趟排序：13  27  38
从上面的排序过程可以看到：大的数一个个往下沉，小的数的就向上浮，跟这个排序方法的名字很贴切。
Java代码实现：
int  sort (int[]  a){
for(int j=1;j<=a.length;j++){
　　for(int i=0;i<a.length-j;i++){
　　if(a[i]>a[i+1]){
　　 int temp;
　　 temp = a[i];
　　 a[i] = a[i+1];
　　 a[i+1] = temp;
}  
  }
return  a;
}
为了提高效率，可以设置一个是否继续比较下去的标志，因为如果数列的排列顺序就是所要求的顺序，那就没必要一个个往下比了，比如：当一趟排序中没有发生数据交换，就可以提前终止。
 
4．快速排序
   快速排序是对冒泡排序的一种改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列；
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与A[I]交换；
4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与A[J]交换；
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束)
过程可如下图表示：
                                  
上面是完成一趟排序的过程，整个排序过程可描述如下：
 
初始状态           （49  38  65  97  76  13  27  49）
 
一次划分之后          ( 27  38  13 )  49 （76  97  65  49）
 
分别进行快速排序     （13）27 （38）
                                    结束              结束      ( 49  65 )  76  ( 97 )
                                        49  ( 65 )  76                          结束
                                                 结束
  有序序列            ( 13  27  38  49  49  65  76  97 )
 
Java代码实现：
int[] sort(int[] data, int low, int high) {
　　// 枢纽元,一般以第一个元素为基准进行划分
　　int i = low;
　　int j = high;
　　if (low < high) {
　　// 从数组两端交替地向中间扫描
　　int pivotKey = data[low];
　　// 进行扫描的指针i,j;i从左边开始,j从右边开始
　　while (i < j) {
　　while (i < j && a[j]>=pivotkey) {
　　j--;
　　}// end while
　　if (i < j) {
　　// 比枢纽元素小的移动到左边
　　data[i] = data[j];
　　i++;
　　}// end if
　　while (i < j && a[i]<=pivotkey) {
　　i++;
　　}// end while
　　if (i < j) {
　　// 比枢纽元素大的移动到右边
　　data[j] = data[i];
　　j--;
　　}// end if
　　}// end while
　　// 枢纽元素移动到正确位置
　　data[i] = pivotKey;
　　// 前半个子表递归排序
　　sort(data, low, i - 1);
　　// 后半个子表递归排序
　　sort(data, i + 1, high);
}// end if
return  a;
}// end sort
 
5．简单选择排序
   其基本思想是：在每一趟排序中将n-i+1(i=1,2,…,n-1)个记录中选取最小的记录和有序序列中第i个记录交换，个人觉得这种排序方法跟冒泡排序很像，比如从小到大排序，冒泡是将大的数一个一个往下沉，而简单选择排序是将小的数一个个往上冒；
Java代码实现：
 
int[] sort(int[] data) {
　　int len = data.length;
　　for (int i = 0; i < len; i++) {
　　int position = i;
　　for (int j = i + 1; j < len; j++) {
　　if (data[position]>data[j])) {
　　position = j;
　　}
　　}
　　Int  temp = data[i];
　　data[i] = data[position];
　　data[position] = temp;
　　}

}

6.树形选择排序：又称锦标赛排序，是一种按照锦标赛的思想进行选择排序的方法。首先对n个记录的关键勃进行两两比较，然后在其中n/2个较小者之间再进行两两比较，如此重复，直到选出最小键字的记录为止，这个过程可用一棵有n个叶子结点的完全二叉树表示，如下图所示：


图中展示了选择最小关键字13的过程，输出13后，将13改为最大值，再进行同样的过程选出次小关键字，如此循环直到完成；
 
由于这种排序方法存在辅助存储空间较多，而且“最大值”进行多余的比较，因为这些缺点，就产生了下面的堆排序；
7.堆排序：只需要一个记录大小的辅助空间，每个待排序的记录大小占有一个存储空间。
我们先看看什么是堆：堆的定义：n个元素的序列（k1,k2,....,kn）当且仅当满足下关系时，称之为堆：
            ｛Ki<=K2i且Ki<=K2i+1｝   或      ｛Ki>=K2i且Ki>=K2i+1｝  
若将和此序列对应的一维数组看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有非终端结点的值均不大于（或不小于）其左，右孩子结点的值。由此，若序列（k1,k2,....,knk）是堆，则堆顶元素（或完全二叉树的根）必为序列中n个元素的最小值（或最大值）。例如，下列两个序列为堆，对应的完全二叉树如下图所示：


 
堆排序思想：
先建一个“大顶堆”，即先选得一个关键字为最大的记录，然后与序列中最后一个记录交换，之后继续对序列中前 n-1 记录进行“筛选”，重新将它调整为一个“大顶堆”再将堆顶记录和第 n-1 个记录交换，如此反复直至排序结束。所谓“筛选”指的是对一棵左/右子树均为堆的完全二叉树，“调整”根结点使整个二叉树为堆.堆排序的特点：在以后各趟的“选择”中，利用在第一趟选择中已经得到的关键字比较的结果,整个过程如下图所示：


java代码示例：

/** 
* <p>堆排序方法 
* <p>基于大根堆的堆排序方法 
*/  
private void heapSort() {  
   Integer tmp; // 用于交换的暂存单元  
   buildHeap(); // 执行初始建堆，并调整  
   for(int i=0; i<array.length; i++) {  
    // 交换堆顶元素array[0]和堆中最后一个元素array[array.length-1-i]  
    tmp = array[0];  
    array[0] = array[array.length-1-i];  
    array[array.length-1-i] = tmp;  
    // 每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
    adjustHeap(0, array.length-1-i);  
   }  
}  
  
/** 
* <p>建堆方法 
* <p>调整堆中0~array.length/2个结点，保持堆的性质 
*  
*/  
private void buildHeap() {  
   // 求出当前堆中最后一个存在孩子结点的索引  
   int pos = (array.length-1)/2;  
   // 从该结点结点开始，执行建堆操作  
   for(int i=pos; i>=0; i--) {  
    adjustHeap(i, array.length); // 在建堆过程中，及时调整堆中索引为i的结点  
   }  
}  
  
/** 
* <p>调整堆的方法 
*  
* @param s 待调整结点的索引 
* @param m 待调整堆的结点的数量(亦即：排除叶子结点) 
*/  
private void adjustHeap(int s, int m) {  
   Integer tmp = array[s]; // 当前待调整的结点  
   int i = 2*s+1; // 当前待调整结点的左孩子结点的索引(i+1为当前调整结点的右孩子结点的索引)  
   while (i<m) {  
    if(i+1<m && array[i]<array[i+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
     i = i+1;  
    }  
    if(array[s]<array[i]) {  
     array[s] = array[i]; // 孩子结点大于当前待调整结点，将孩子结点放到当前待调整结点的位置上  
     s = i; // 重新设置待调整的下一个结点的索引  
     i = 2*s+1;  
    }   
    else { // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
     break;  
    }  
    array[s] = tmp; // 当前待调整的结点放到比其大的孩子结点位置上  
   }  
}  

 8.归并排序:是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
如　设有数列{6，202，100，301，38，8，1} 　　
 
初始状态： [6] [202] [100] [301] [38] [8] [1] 比较次数
 
i=1    [6 202 ] [ 100 301] [ 8 38] [ 1 ]　3 　
　
i=2    [ 6 100 202 301 ] [ 1 8 38 ]　4 　
　
i=3　 [ 1 6 8 38 100 202 301 ] 4 　　
 
总计：　11次
 
 下图展示了归并排序的过程


java代码示例：

/** 
*归并排序，要求待排序的数组必须实现Comparable接口 
*/  
public class MergeSort implements SortStrategy  
{　private Comparable[] bridge;  
　　　 /** 
　　　 *利用归并排序算法对数组obj进行排序 
　　　 */  
　　　 public void sort(Comparable[] obj)  
　　　 {　 if (obj == null)  
　　　　　　　{　　throw new NullPointerException("The param can not be null!");  
　　　　　　　}  
　　　　　　　bridge = new Comparable[obj.length];　//初始化中间数组  
　　　　　　　mergeSort(obj, 0, obj.length - 1);　//归并排序  
　　　　　　　bridge = null;  
　　　 }  
　　　 /** 
　　　 *将下标从left到right的数组进行归并排序 
　　　 *@param obj　要排序的数组的句柄 
　　　 *@param left 要排序的数组的第一个元素下标 
　　　 *@param right 要排序的数组的最后一个元素的下标 
　　　 */  
　　　 private void mergeSort(Comparable[] obj, int left, int right)  
　　　 {　　if (left < right)  
　　　　　　　{　　 int center = (left + right)/2;  
　　　　　　　　　　 mergeSort(obj, left, center);  
　　　　　　　　　　 mergeSort(obj, center + 1, right);  
　　　　　　　　　　 merge(obj, left, center, right);  
　　　　　　　}  
　　　 }  
　　　 /** 
　　　 *将两个对象数组进行归并，并使归并后为升序。归并前两个数组分别有序 
　　　 *@param obj 对象数组的句柄 
　　　 *@param left 左数组的第一个元素的下标 
　　　 *@param center 左数组的最后一个元素的下标 
　　　 *@param right 右数组的最后一个元素的下标 
　　　 */  
　　　 private void merge(Comparable[] obj, int left, int center, int right)   
　　　 {　 int mid = center + 1;  
　　　　　　　int third = left;  
　　　　　　　int tmp = left;  
　　　　　　　while (left <= center && mid <= right)  
　　　　　　　{　　 //从两个数组中取出小的放入中间数组  
　　　　　　　　　　 if (obj[left].compareTo(obj[mid]) <= 0)  
　　　　　　　　　　 {　　　bridge[third++] = obj[left++];  
　　　　　　　　　　 }　　else  
　　　　　　　　　　　　　　bridge[third++] = obj[mid++];  
　　　　　　　}  
　　　　　　　//剩余部分依次置入中间数组  
　　　　　　　while (mid <= right)  
　　　　　　　{　bridge[third++] = obj[mid++];  
　　　　　　　}  
　　　　　　　while (left <= center)  
　　　　　　　{　　bridge[third++] = obj[left++];  
　　　　　　　}  
　　　　　　　//将中间数组的内容拷贝回原数组  
　　　　　　　copy(obj, tmp, right);  
　　　 }  
　　　 /** 
　　　 *将中间数组bridge中的内容拷贝到原数组中 
　　　 *@param obj 原数组的句柄 
　　　 *@param left 要拷贝的第一个元素的下标 
　　　 *@param right 要拷贝的最后一个元素的下标 
　　　 */  
　　　 private void copy(Comparable[] obj, int left, int right)  
　　　 {　 while (left <= right)  
　　　　　　　{　 obj[left] = bridge[left];  
　　　　　　　　　　 left++;  
　　　　　　　} }  
}