排序3—选择排序

前言：

     本来应该早一些跟新这篇博客的，但是最近有一些小烦恼耽搁了，不不不，学习还是不能停啊。那么先来预告一下我们要说什么呢？
这里我们要说的首先是“简单选择排序”，然后你观察一下前面的博客就会发现，排序还是查找，都是有一个递进优化的趋势，所以之后就是优化版的“树形选择排序”，然后是更优化的“堆排序”。那么我们开始吧！

一、简单选择排序

【算法描述】

1）设待排序的记录存放在数组r[1…n]中。第一趟从r[1]开始，通过n-1次比较，从n个记录中选出关键字最小的记录，记为r[k]，交换r[1]和r[k]。
2）第二趟从r[2]开始，通过n-2次比较，从n-1个记录中选出关键字最小的记录，记为r[k]，交换r[2]和r[k]。
3）依次类推，第i趟从r[i]开始，通过n-i次比较，从n-i+1个记录中选出关键字最小的记录，记为r[k]，交换r[i]和r[k]。
4）经过n-1趟，排序完成。
所以当时我写插入排序的时候让大家不要混淆，不知道现在分清楚了没有呢，插入排序是在有序序列基础上插入，而交换排序就是不断的找到关键字交换，哈哈。

（这个很简单的，所以就看看就理解了）简单代码演示：

void SelectSort(SqList &L) 
{ 
   //对顺序表L做简单选择排序
	int i,j,k;
	ElemType t;
    for(i=1;i<L.length;++i) 
	{  												//在L.r[i..L.length] 中选择关键字最小的记录
		k=i;                 
        for(j=i+1;j<=L.length;++j)
			if(L.r[j].key<L.r[k].key)  k=j;			//k指向此趟排序中关键字最小的记录
		if(k!=i) {t=L.r[i];L.r[i]=L.r[k];L.r[k]=t;} //交换r[i]与r[k]        
     }												//for  
}				

     来，我们会发现移动复杂度比较好，但是查找时间复杂度是O(n²)级别的。所以我们要优化查找的话，就有了树形选择排序。

二、树形选择排序

     树形选择排序，又称为锦标赛排序，是一种按照锦标赛的思想进行选择排序的方法。首先对n个记录的关键字进行两两比较，然后在其中[n/2]个较小者之间再进行两两比较，如此重复，直至选出最小关键字的记录为止。这个过程可用一棵有n个叶子节点的完全二叉树表示。
     由于含有n个叶子结点的完全二叉树的深度是 log₂n+1，所以查找的时间复杂度也就降低为log₂n。
我们来看看一个图就很好理解了

     你看，我们不断的重复上述的过程，然后就排好序了，查找的次数也越来越少。到那时细心地你发现了我们的辅助空间变多了，所以为了节省辅助空间。就有了堆排序。

三、堆排序

     

堆排序是一种树形选择排序，在排序过程中，将待排序的记录r[1…n]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序的序列中选择关键字最大（最小）的记录。

     来，先来解释一下“关系”。虽然你在我的图论博客中也可以看到这个，但是还是提一下，这里的关系就是如果给结点按顺序赋值，那么双亲结点值为n，左孩子一定是2n，右孩子一定是2n+1。
这里我们的堆有大根堆（大顶堆都是一样的），小顶堆。
【算法步骤】

1）按堆的定义将待排序序列r[1…n]调整为大根堆（这个过程称为建初堆），交换r[1]和r[n]，则r[n]为关键字最大的记录。
2）将r[1…n-1]重新调整为堆，交换r[[1]和r[n-1]，则r[n-1]为关键字次大的记录。
3）循环n-1次，直到交换了r[1]和r[2]为止，得到了一个非递减的有序序列（大根堆）。

     那么你会发现，如何调整堆就很重要了，我自己总结的方法就是根到叶子比较，不满足交换即可。
堆排序我自己的步骤就是：

• 建立无序堆
• 输出顶元素
• 调整堆
• 重复如上操作。

来看看演示代码：

//算法堆排序
#include <iostream>
using namespace std;
#define  MAXSIZE  20          						//顺序表的最大长度
typedef struct
{
	int key;
	char *otherinfo;
}ElemType;
//顺序表的存储结构                         
typedef struct
{
    ElemType *r;	         						//存储空间的基地址
    int  length;            						//顺序表长度
}SqList;											//顺序表类型

//用算法 筛选法调整堆
void HeapAdjust(SqList &L,int s,int m)
{ 
   //假设r[s+1..m]已经是堆，将r[s..m]调整为以r[s]为根的大根堆
	ElemType rc;
	int j;
	rc=L.r[s];
    for(j=2*s;j<=m;j*=2)
	{												//沿key较大的孩子结点向下筛选
		if(j<m&&L.r[j].key<L.r[j+1].key) ++j;		//j为key较大的记录的下标
        if(rc.key>=L.r[j].key) break;      			//rc应插入在位置s上
		L.r[s]=L.r[j]; s=j; 
    }
	L.r[s]=rc;                          			//插入
}
													//HeapAdjust								
void Create_Sq(SqList &L)
{
	int i,n;
	cout<<"请输入数据个数，不超过"<<MAXSIZE<<"个。"<<endl;
	cin>>n;											//输入个数
	cout<<"请输入待排序的数据:\n";
	while(n>MAXSIZE)
	{
		cout<<"个数超过上限，不能超过"<<MAXSIZE<<"，请重新输入"<<endl;
		cin>>n;
	}
	for(i=1;i<=n;i++)
	{
		cin>>L.r[i].key;
		L.length++;
	}
}

//用算法 建初堆
void CreatHeap(SqList &L)
{
	//把无序序列L.r[1..n]建成大根堆
	int i,n;
	n=L.length;
	for(i=n/2;i>0;--i)       					//反复调用HeapAdjust 
		HeapAdjust(L,i,n);
}												//CreatHeap

void HeapSort(SqList &L) 
{ 
	//对顺序表L进行堆排序 
	int i;
	ElemType x;
	CreatHeap(L);              					//把无序序列L.r[1..L.length]建成大根堆 
	for(i=L.length;i>1;--i)
	{ 
		x=L.r[1];               				//将堆顶记录和当前未经排序子序列L.r[1..i]中最后一个记录互换 
		L.r[1]=L.r[i];            
		L.r[i]=x; 
		HeapAdjust(L,1,i-1);					//将L.r[1..i-1]重新调整为大根堆 
   }//for 
}//HeapSort
void show(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
		cout<<L.r[i].key<<endl;
}
void main()
{
	SqList L;
	L.r=new ElemType[MAXSIZE+1];
	L.length=0;
	Create_Sq(L);
	HeapSort(L);
	cout<<"排序后的结果为："<<endl;
	show(L);
}

后记：

     那么到这里选择排序就完结了，之后就是归并和基数排序。如有误，评论哦，谢谢。