几个有趣的排序

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