数据结构学习笔记 --- 排序（选择排序、堆排序）

1. 引言 

本文主要讲解一些常见的选择排序和堆排序。

2. 选择排序

选择排序的基本思想是每步从待排序的记录中选出排序码最小的记录，顺序存放在已排序的记录序列的后面，直到全部排完。选择排序中主要使用直接选择排序和堆排序。

直接选择排序(不稳定)

    直接选择排序的过程是：首先在所有记录中选出序码最小的记录，把它与第1个记录交换，然后在其余的记录内选出排序码最小的记录，与第2个记录交换......依次类推，直到所有记录排完为止。

    无论文件初始状态如何，在第i趟排序中选出最小关键字的记录，需要做n-i次比较，因此，总的比较次数为n(n-1)/2=O(n^2)。当初始文件为正序时，移动次数为0；文件初态为反序时，每趟排序均要执行交换操作，总的移动次数取最大值3(n-1)。直接选择排序的平均时间复杂度为O(n^2)。直接选择排序是不稳定的。

void Dir_Choose(int A[],int n)  //直接选择排序
{
    int k,t;
    for(int i=0;i<n-1;i++)
    {
        k=i;
        for(int j=i+1;j<n;j++)
        {
            if(A[j]<A[k]) k=j;
        }
        if(k!=i)
        {
            t=A[i];
            A[i]=A[k];
            A[k]=t;
        }
    }
}

#include "ds.h"

/* 选择排序的思想是：每一趟在 n-i+1(1<=i<n) 个记录中选取关键字最小的记录作为有序序列中的第i个记录。 */
/* 简单排序的操作为：通过 n-i 次关键字间的比较,从 n-i+1(1<=i<n) 个关键字中选出最小的记录，并和第i个记录交换之。 */

#define 	MAX_SIZE 	20			// 一个用作示例的小顺序表的最大长度
typedef		int			KeyType;	// 定义关键字类型为整型
typedef 	int 		InfoType; // 定义其它数据项的类型

#define 	EQ(a,b) 	((a)==(b))
#define 	LT(a,b) 	((a)<(b))
#define 	LQ(a,b) 	((a)<=(b))

struct RedType						// 记录类型
{
	KeyType		key;				// 关键字项
	InfoType	otherinfo;			// 其它数据项，具体类型在主程中定义
};

struct SqList						// 顺序表类型
{
	RedType		r[MAX_SIZE+1];		// r[0]闲置或用作哨兵单元
	int 		length;				// 顺序表长度
};

// 返回在L.r[i..L.length]中key最小的记录的序号
int SelectMinKey(SqList L, int i)
{
	KeyType min;
	int 	j, k;
	k = i;			// 设第i个为最小
	min = L.r[i].key;
	for (j = i + 1; j <= L.length; j++)
	{
		if (L.r[j].key < min)	// 找到更小的
		{
			k = j;
			min = L.r[j].key;
		}
	}
	return k;
}

// 对顺序表L作简单选择排序。算法10.9
void SelectSort(SqList &L)
{
	int i, j;
	RedType t;
	
	for (i = 1; i <= L.length; ++i)
	{//  选择第i小的记录，并交换到位
		
		j = SelectMinKey(L, i);			// 在L.r[i..L.length]中选择key最小的记录
		if (j != i)
		{
			// 与第i个记录交换
			t = L.r[i];
			L.r[i] = L.r[j];
			L.r[j] = t;
		}
	}
}

// 树形选择排序
void TreeSort(SqList &L)
{ 
   int i,j,j1,k,k1,l,n=L.length;
   RedType *t;
   l=(int)ceil(log(n)/log(2))+1; // 完全二叉树的层数
   k=(int)pow(2,l)-1; // l层完全二叉树的结点总数
   k1=(int)pow(2,l-1)-1; // l-1层完全二叉树的结点总数
   t=(RedType*)malloc(k*sizeof(RedType)); // 二叉树采用顺序存储结构
   for(i=1;i<=n;i++) // 将L.r赋给叶子结点
     t[k1+i-1]=L.r[i];
   for(i=k1+n;i<k;i++) // 给多余的叶子的关键字赋无穷大
     t[i].key=INT_MAX;
   j1=k1;
   j=k;
   while(j1)
   { // 给非叶子结点赋值
     for(i=j1;i<j;i+=2)
       t[i].key<t[i+1].key?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);
     j=j1;
     j1=(j1-1)/2;
   }
   for(i=0;i<n;i++)
   {
     L.r[i+1]=t[0]; // 将当前最小值赋给L.r[i]
     j1=0;
     for(j=1;j<l;j++) // 沿树根找结点t[0]在叶子中的序号j1
       t[2*j1+1].key==t[j1].key?(j1=2*j1+1):(j1=2*j1+2);
     t[j1].key=INT_MAX;
     while(j1)
     {
       j1=(j1+1)/2-1; // 序号为j1的结点的双亲结点序号
       t[2*j1+1].key<=t[2*j1+2].key?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);
     }
   }
   free(t);
}

void print(SqList L)
{
   	int i;
   	for(i = 1; i <= L.length; i++)
     	printf("(%d,%d)", L.r[i].key, L.r[i].otherinfo);
   	printf("\n");
}

#define N 8
int main()
{
   RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
   SqList l;
   int i;
   for(i=0;i<N;i++)
     l.r[i+1]=d[i];
   l.length=N;
   printf("排序前:\n");
   print(l);
#if 0
   	SelectSort(l);
#else
	TreeSort(l);
#endif
   printf("排序后:\n");
   print(l);
}

3. 堆排序

 堆排序是一种树形选择排序，是对直接选择排序的有效改进。n个关键字序列

K1,K2,...,Kn称为堆，当且仅当该序列满足(Ki<=K2i且Ki<=K2i+1)或(Ki>=K2i且Ki>=K2i+1),(1<=i<=n/2)。根结点(堆顶)的关键字是堆里所有结点关键字中最小者，称为小根堆；根结点的关键字是堆里所有结点关键字中最大者，称为大根堆。

    若将此序列所存储的向量R[1..n]看作是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

    堆排序的关键步骤有两个：一是如何建立初始堆；二是当堆的根结点与堆的最后一个结点交换后，如何对少了一个结点后的结点序列做调整，使之重新成为堆。堆排序的最坏时间复杂度为O(nlog2n),堆排序的平均性能较接近于最坏性能。由于建初始堆所需的比较 次数较多，所以堆排序不适宜于记录较少的文件。堆排序是就地排序，辅助空间为O(1)，它是不稳定的排序方法。

#include "ds.h"

#define 	MAX_SIZE 	20			// 一个用作示例的小顺序表的最大长度
typedef		int			KeyType;	// 定义关键字类型为整型
typedef 	int 		InfoType; // 定义其它数据项的类型

#define 	EQ(a,b) 	((a)==(b))
#define 	LT(a,b) 	((a)<(b))
#define 	LQ(a,b) 	((a)<=(b))

struct RedType						// 记录类型
{
	KeyType		key;				// 关键字项
	InfoType	otherinfo;			// 其它数据项，具体类型在主程中定义
};

struct SqList						// 顺序表类型
{
	RedType		r[MAX_SIZE+1];		// r[0]闲置或用作哨兵单元
	int 		length;				// 顺序表长度
};

typedef 	SqList 		HeapType;

// 已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数
// 调整H.r[s]的关键字，使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言)
void HeapAdjust(HeapType &H, int s, int m)
{
	RedType 	rc;
	int 		j;
	rc = H.r[s];
	// 沿key较大的孩子结点向下筛选
	for (j = 2*s; j <= m; j *= 2)
	{
		if (j < m && LT(H.r[j].key, H.r[j+1].key))
			++j;	// j为key较大的记录的下标
		if (!LT(rc.key, H.r[j].key))
			break;	// rc应插入在位置s上
		H.r[s] = H.r[j];
		s = j;
	}
	H.r[s] = rc;	// 插入
}

// 对顺序表H进行堆排序。算法10.11
void HeapSort(HeapType &H)
{
	RedType t;
	int 	i;
	for (i = H.length/2; i > 0; --i)	// 把H.r[1..H.length]建成大顶堆
		HeapAdjust(H, i, H.length);
	for (i = H.length; i > 1; --i)
	{// 将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换
		t = H.r[1];
		H.r[1] = H.r[i];
		H.r[i] = t;
		HeapAdjust(H, 1, i-1); // 将H.r[1..i-1]重新调整为大顶堆
	}
}

void print(HeapType H)
{
   	int i;
   	for(i=1;i<=H.length;i++)
     	printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo);
   	printf("\n");
}

#define N 8
int main()
{
   RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
   HeapType h;
   int i;
   for(i=0;i<N;i++)
     h.r[i+1]=d[i];
   h.length=N;
   printf("排序前:\n");
   print(h);
   HeapSort(h);
   printf("排序后:\n");
   print(h);
}