几个有趣的排序

几个有趣的排序

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