几个有趣的排序

1.交换次数少的选择排序

维护两个序列，待排序和已排序。每次从待排序里找出最大（最小）的放到已排序的末尾，因为交换比查找慢，所以对于个数不多的数列，选择排序比冒泡排序快。

另外，如果每次找出最大和最小的分别放到头尾，能节省一半的交换次数。

实例代码

/*优化版本的选择排序一次循环中同时确定最大最小的位置，循环趟数由n减为n/2交换次数O(n),比较次数O(n^2) */#include <iostream>#define swap(x, y) (x=(x)+(y), y=(x)-(y), x=(x)-(y))using namespace std;template <class T>int getLength(T &array){    return sizeof(array)/sizeof(array[0]);}int main(){    int a[] = {2,5,4,6,7,3,1,8,0,9,11,66,25,77,54,75,33};    //int b[];    int i, j, max, min, len;    len = getLength(a);     for(i=0; i<len/2; i++){        min = i;        max = len-1 - i;        for(j=i+1; j<len; j++){            if(a[j] < a[min])                swap(a[j], a[min]);            if(a[len-1-j] > a[max])                swap(a[len-1-j], a[max]);        }    }    //cout<< len/2<< endl;len/2结果是舍小数点后位数     for(i=0; i<len; i++)        cout<< a[i]<< " ";    cout<< endl;}

2.利用上次结果的锦标赛排序

这是一个与堆排序有些类似的排序方法，被排序的数作为一颗二叉树的叶子，当第一趟找出最小值后，最小值设为MAX，并从上一轮最小值所在二叉树进行下一趟比较，这时每趟比较次数为树的高度，即logn，比较n-1趟，加上最开始一趟比较n-1次，总次数比选择排序少，但增加了空间。

实例代码

#include <iostream>#include <limits>using namespace std;template <class T>int getLength(T &array){    return sizeof(array)/sizeof(array[0]);}void Adjust(int *b, int x, int n);void GameSort(int *a, int n){    int *b, i, len=1;    while(len < n){        len <<= 1;    }    len = len * 2 - 1;    b = (int *)malloc(sizeof(int) * len);    for(i=len/2; i<len; i++)        b[i] = (i-len/2<n) ? a[i-len/2] : INT_MAX; //如果待排序数不够组成一个满二叉树，则需要补MAX补满    for(i=len/2-1; i>=0; i--){        b[i] = min(b[2*i+1], b[2*i+2]);    }     /*    for(i=0; i<len; i++)        cout<< b[i]<< " ";        cout<<endl;    */    for(i=0; i<n; i++){        a[i] = b[0];        cout<< b[0]<< endl;        Adjust(b, 0, len);    }    free(b);}void Adjust(int *b, int x, int n){ //每次adjust，都会使剩下待处理数中的最小值来到整棵树的根节点上     /*    传入参数中，x为待处理的根节点    */    int l, r;    l = 2 * x + 1;    r = 2 * x + 2;    if(l>=n){        b[x] = INT_MAX;        return;    }    if(r>=n){        b[x] = b[l];        return;    }    if (b[l] == b[x]){           Adjust(b, l, n);       }    else{           Adjust(b, r, n);       }    b[x] = min(b[l], b[r]);     //值得注意的是，b[x]的赋值决定工作直接在每个adjust下，没有嵌套在任何条件语句中，因而根部的b[x]值是在整棵树都adjust完毕后一层一层从叶子到根再比较上来的，所以每次最小值才能来到b[0]的位置 }int main(){    int i;    int a[] = {3,4,1,6,2,8,7,9};    GameSort(a, getLength(a));    for(i=0; i<getLength(a); i++)        cout<< a[i]<< " ";        cout<< endl;}

3.进一步节约空间的堆排序

排序堆有最大堆和最小堆，就是每个根节点的值都比他的两个叶子节点大/小1。
具体到排序中，先是给整个数组变成一个排序堆，但这时是整体有序，局部无序；之后从最后一个叶子节点开始，依次与0号根节点交换并重构堆，即可得到有序数组

实例代码

#include <iostream>#include <cmath>#define swap(x, y) (x=x+y, y=x-y, x=x-y) template <class T>int getLength(T &array){    return sizeof(array)/sizeof(array[0]);}using namespace std;void Print_Tree(int[]);void Heap_Maxify(int *a, int i, int heap_size){    int l = 2 * i + 1;    int r = 2 * i + 2;    int largest;    /*    以下一段功能为使单元树里最大的来到根部    */     if(l < heap_size && a[l] > a[i])        largest = l;    else        largest = i;    if(r < heap_size && a[r] > a[largest])        largest = r;    if(largest != i){        swap(a[i], a[largest]);        Heap_Maxify(a, largest, heap_size);    }    Print_Tree(a);//一开始是越往上（根部）越大，后来慢慢的大数开始下移}void Build_Maxheap(int *a, int heap_size){    int i;    for(i=(floor(heap_size-1)/2); i>=0; i--){        Heap_Maxify(a, i, heap_size);    }}void Heap_Sort(int *a, int heap_size) {    int i;    Build_Maxheap(a, heap_size);    for(i=heap_size-1; i>=0; i--){        swap(a[i], a[0]);        Heap_Maxify(a, 0, i);    }}void Print_Tree(int *a){    printf("--------------------------%d----------------------------------\n",a[0]);    printf("--------------%d--------------------------%d-------------------\n",a[1], a[2]);    printf("--------%d-----------%d----------%d------------------%d--------\n",a[3], a[4],a[5], a[6]);    printf("---%d-------%d---%d------%d---%d------%d-----------%d-----%d---\n\n\n\n",a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14] );}int main(){    int i;    int a[]={2,5,4,6,7,3,1,8,0,9,11,66,25,77,54};    int heap_size;    heap_size = getLength(a);    if(heap_size % 2 == 0){//因为必须奇数个才能构成排序堆，所以有一个补全过程         heap_size++;        a[heap_size-1] = INT_MAX;//根据要求可能改为INT_MIN     }    Heap_Sort(a, heap_size);//  Print_Tree(a);    /*    for(i=0; i<heap_size; i++)        if(a[i] != INT_MAX)            cout<< a[i]<< " ";    cout<< endl;    */    return 0;}

---

1. 排序堆的节点要么没子节点，要么左右节点都有
   利用堆排序与锦标赛排序的区别在于整个堆都能用来存储待排序数，而锦标赛排序只有最顶层的叶子是排序数，因此空间复杂度要好一点。 ↩