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