数据结构上机实验-希尔排序，快速排序，堆排序

最新推荐文章于 2021-05-18 13:06:49 发布

ccq1n

最新推荐文章于 2021-05-18 13:06:49 发布

阅读量2.6k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：数据结构—实验文章标签：数据结构希尔排序快速排序堆排序

本文链接：https://blog.youkuaiyun.com/qq_29600137/article/details/50364660

数据结构—实验专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了希尔排序、快速排序和堆排序这三种经典排序算法的实现原理与步骤，并提供了完整的C/C++代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.希尔排序

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

//希尔排序 
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
typedef struct 
{
	int key;
	char *otherinfo;
}ElemType;
typedef struct 
{
	ElemType *r;
	int length;
}SqList;
void ShellInsert(SqList &L,int dk)
{
	int i,j;
	for(i=dk+1;i<=L.length;i++)
	{
		if(L.r[i].key<L.r[i-dk].key)
		{
			L.r[0]=L.r[i];
			for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk)
			{
				L.r[j+dk]=L.r[j];
			}
			L.r[j+dk]=L.r[0];
		}
	}
}
void ShellSort(SqList &L,int dt[],int t)
{
	int k;
	for(k=0;k<t;k++)
	{
		ShellInsert(L,dt[k]);
	}
}
int main()
{
	SqList L;
	L.r=new ElemType[100];
	L.length=0;
	printf("请输入数据个数：");
	int nn;
	scanf("%d",&nn);
	printf("请输入待排序数据：\n");
	for(int i=1;i<=nn;i++)
	{
		scanf("%d",&L.r[i].key);
		L.length++;
	}
	int i,t;
	int *dt=new int[1000];//增量数组 
	printf("输入增量的个数：");
	int yy;
	scanf("%d",&yy);
	for(i=0;i<yy;i++)
	{
		scanf("%d",&dt[i]);
	} 
	ShellSort(L,dt,yy);
	printf("排序后的结果：");
	for(i=1;i<=nn;i++)
	{
		printf("%d ",L.r[i].key);
	}
	printf("\n");
	return 0;
}

<strong><span style="font-size:24px;">2.快速排序</span></strong>

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

//快速排序 
#include <iostream>
using namespace std;
#define  MAXSIZE  20          			//顺序表的最大长度
typedef struct
{
	int key;
	char *otherinfo;
}ElemType;
//顺序表的存储结构                         
typedef struct
{
    ElemType *r;	         						//存储空间的基地址
    int  length;            						//顺序表长度
}SqList;											//顺序表类型
int Partition(SqList &L,int low,int high)
{ 
	//对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置
	int pivotkey;
	L.r[0]=L.r[low];                    	//用子表的第一个记录做枢轴记录
	pivotkey=L.r[low].key;		   			//枢轴记录关键字保存在pivotkey中
	while(low<high)
	{										//从表的两端交替地向中间扫描
		while(low<high&&L.r[high].key>=pivotkey) --high;
		L.r[low]=L.r[high];					//将比枢轴记录小的记录移到低端
		while(low<high&&L.r[low].key<=pivotkey) ++low;
		L.r[high]=L.r[low];					//将比枢轴记录大的记录移到高端
	}//while
	L.r[low]=L.r[0];						//枢轴记录到位
	return  low;							//返回枢轴位置
}//Partition
void QSort(SqList &L,int low,int high)
{	//调用前置初值：low=1; high=L.length;
    //对顺序表L中的子序列L.r[low..high]做快速排序
	int pivotloc;
    if(low<high)
	{										//长度大于1
       pivotloc=Partition(L,low,high); 		//将L.r[low..high]一分为二，pivotloc是枢轴位置
       QSort(L,low,pivotloc-1);				//对左子表递归排序
       QSort(L,pivotloc+1,high);        	//对右子表递归排序
	}
}											//QSort
void QuickSort(SqList &L)
{
   //对顺序表L做快速排序
   QSort(L,1,L.length);
}											//QuickSort								
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 show(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
		cout<<L.r[i].key<<endl;
}
int main()
{
	SqList L;
	L.r=new ElemType[MAXSIZE+1];
	L.length=0;
	Create_Sq(L);
	QuickSort(L);
	cout<<"排序后的结果为："<<endl;
	show(L);
}

3.堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

//堆排序 
#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]重新调整为大根堆 **
   	}
}
void show(SqList L)
{
	int i;
	for(i=1;i<=L.length;i++)
		cout<<L.r[i].key<<endl;
}
int main()
{
	SqList L;
	L.r=new ElemType[MAXSIZE+1];
	L.length=0;
	Create_Sq(L);
	HeapSort(L);
	cout<<"排序后的结果为："<<endl;
	show(L);
}