数据结构学习笔记 --- 排序(选择排序、堆排序)

原创 2012年03月24日 21:07:01

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<=K2iKi<=K2i+1)(Ki>=K2iKi>=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);
}


相关文章推荐

数据结构学习笔记5-寻找最小的k个数(选择排序和堆排序)

本文摘自《寻找最小的k个数》题目描述输入n个整数,输出其中最小的k个。

数据结构-选择排序-堆排序

堆排序(Heap Sort)只需要一个记录大小的辅助空间,每个待排序的记录仅占有一个存储空间。 堆定义:满足ki 堆排序方法对记录较少的文件不值得提倡,对n较大的文件还是很有效的。因为其运行时间主要耗...

数据结构例程——选择排序之堆排序

本文是[数据结构基础系列(9):排序]中第7课时[选择排序之堆排序]的例程。#include #define MaxSize 20 typedef int KeyType; //定义关键字类型...

数据结构面试之十——排序1(直接插入、希尔、冒泡、直接选择排序)

题注:《面试宝典》有相关习题,但思路相对不清晰,排版有错误,作者对此参考相关书籍和自己观点进行了重写,供大家参考。 九、数据结构面试之十——排序1(直接插入、希尔、冒泡、直接选择排序) 1.直接插...

Java数据结构和算法-简单排序(2-选择排序)

选择排序改进了冒泡排序,将其必要的交换时间由O(N^2)减小为O(N),虽然在比较效率上两者没有太大差别,但是对于大记录量的排序需要在内存中移动来说,这就使得移动的时间和比较的时间相比要重要很多。选择...

我---对‘数据结构’中‘排序’的理解 ---------3:选择排序--(二)堆排序

堆排序  是由 树形选择排序 优化而来锦标赛排序:锦标赛排序,也称为树形选择排序(Tree Selection Sort),是一种按照锦标赛的思想进行选择排序的方法。首先对n个记录进行两两比较...
  • zx824
  • zx824
  • 2011年02月25日 16:28
  • 688

数据结构&算法实践—【排序|选择排序】堆排序

转载请注明出处:http://blog.csdn.net/wklken 回主目录 排序>>选择排序>>堆排序 List: 0.概念+伪代码+示例分析 1.堆排...
  • wklken
  • wklken
  • 2012年06月02日 22:17
  • 4063

【数据结构和算法】排序算法之二:选择排序和堆排序

一  选择排序 (1)思想 假设有十张扑克牌放在桌上,我们需要按从小到大的顺序拿到手上,每次只能选择一张牌拿到手上,那么每一次我们都必须从桌上的扑克牌中选择最小的牌拿起来,一次循环十次,这样就将扑克牌...

C++代码,数据结构-内部排序-选择排序-堆排序

最简单的选择排序,的时间复杂度为N2;其主要操作就是比较,从减少次数出发来改进算法,书上提到了树形选择排序,但是有需要的辅助空间较多等缺点,为了弥补,威洛姆斯提出了另一种形式的选择排序——堆排序, ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据结构学习笔记 --- 排序(选择排序、堆排序)
举报原因:
原因补充:

(最多只允许输入30个字)