数据结构与C语言实现（十二）——排序合集

最新推荐文章于 2022-09-30 09:38:29 发布
最新推荐文章于 2022-09-30 09:38:29 发布
阅读量204 收藏
点赞数
分类专栏： 数据结构与C语言实现 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w8253497062015/article/details/78363556
版权 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 200
#define MAXDATA 65535

int arry[MAXSIZE];

struct HNode
{
	int data[MAXSIZE + 1];
	int size;
	int num;
};
typedef struct HNode* Heap;

void Print()
{
	for (int i = 0; i < MAXSIZE; i++)
		printf("%d  ", arry[i]);
	putchar('\n');
}

void Init()
{
	for (int i = 0; i < MAXSIZE/2; i++)
		arry[i] = i;
	for (int i = MAXSIZE - 1; i >= MAXSIZE/2; i--)
		arry[i] = 300 - i;
}


void Insert_Sort(int arry[], int N)
{
	Init();
	int i;
	for (int p = 1; p < N; p++)//拿了一手牌，一张一张摸牌
	{
		int Tmp = arry[p];
		for (i = p; i > 0 && arry[i - 1] > Tmp; i--)
			//	i > 0 && arry[i - 1]，任意不满足都退出循环
			arry[i] = arry[i - 1];
		//找到i的下标后，向后移动挪出一个位置
		arry[i] = Tmp;
		//i下标存放的数字就是Tmp
	}
}

void Shell_Sort(int arry[],int N)
{
	Init();
	int D;
	int i;
	Heap H;
	for (D = N / 2; D > 0; D /= 2)//进行D间隔排序，直到间隔为1
	{	
		for (int p = D; p < N; p++)//从D开始，往后一个一个来
		{
			int Tmp = arry[p];
			for (i = p; i > D && arry[i - D] > Tmp; i-=D)//注意，这里是间隔的核心，每次和D间隔之前的那个比较
				//从手上的最后一张牌数起，和D间隔之前的那个数字比较 ，直到手里牌的某一张（下标为i-1）小于或等于Tmp
				arry[i] = arry[i - D];
			//找到i的下标后，向后移动挪出一个位置
			arry[i] = Tmp;
			//i下标存放的数字就是Tmp
		}
	}

}
//用最大堆实现堆排序
Heap Create_Heap()
{
	Init();
	int i,j;
	Heap H = (Heap)malloc(sizeof(struct HNode));
	printf("创建的堆为——");
	H->data[0] = MAXDATA;
	for (i = 1; i < MAXSIZE + 1; i++)
	{
		H->data[i] = arry[i - 1];
	}
	//for (i = 0; i <= MAXSIZE; i++)
	//{
	//	printf("%d  ", H->data[i]);
	//}
	H->num = MAXSIZE + 1;
	H->size = MAXSIZE;

	return H;
}

Heap Build_Heap()
{
	int child, parent;
	Heap H = Create_Heap();
	for (int i = H->size / 2; i > 0; i--)//从倒数第二行开始调整
	{
		int temp = H->data[i];
		for (parent = i; parent * 2 <= H->size; )//破坏循环的条件是孩子到了堆的外面
		{
			child = parent * 2;
			if ((H->data[child + 1] > H->data[child])&&(child != H->size))
				child++;//如果右儿子比较大，那么右儿子++
			//父亲和儿子身份对调
			if (temp < H->data[child])
			{
				H->data[parent] = H->data[child];
				parent = child;
			}			
			else
			{
				break;
			}
		}
		H->data[parent] = temp;
	}
	return H;
}

int Delete_Heap(Heap H)
{
	int child, parent;
	int ans = H->data[1];
	H->data[1] = H->data[H->size];
	int temp = H->data[1];
	H->size--;
	for (parent = 1; parent * 2 <= H->size;)//注意这里是小于等于
	{
		child = parent * 2;
		if ((H->data[child + 1] > H->data[child]) && (child != H->size))
			child++;//如果右儿子比较大，那么右儿子++
					//父亲和儿子身份对调
		if (temp < H->data[child])
		{
			H->data[parent] = H->data[child];
			parent = child;
		}
		else
		{
			break;
		}
	}
		H->data[parent] = temp;

	return ans;
}

void Heap_Sort(int arry[], int N)
{
	Heap H = Build_Heap();
	for (int i = N - 1; i >= 0; i--)
	{
		arry[i] = Delete_Heap(H);
	}
}

//归并,将两个已经排序好的数组合成一个排序好的数组
void Merge(int arry[], int temp[],int L,int R,int RightEnd)
{
	int LeftEnd = R - 1;
	int tmp = L;
	int Num = RightEnd - L + 1;//计算元素总个数
	//如果两边都没到终点，那么选取小的那个优先放入中间数组
	while (L <= LeftEnd && R <= RightEnd)
	{
		if (arry[L] <= arry[R]) temp[tmp++] = arry[L++];
		else
		{
			temp[tmp++] = arry[R++];
		}
	}
	while (L <= LeftEnd)//如果左边还没到终点
		temp[tmp++] = arry[L++];
	while (R <= RightEnd)//如果右边还没到终点
		temp[tmp++] = arry[R++];
	//从尾巴向前把值赋值会arry数组里，赋值多少次呢？赋值M次
	for (int i = 0; i < Num; i++, RightEnd--)
		arry[RightEnd] = temp[RightEnd];
}

void Merge1(int arry[], int temp[], int L, int R, int RightEnd)
{
	int LeftEnd = R - 1;
	int tmp = L;
	int Num = RightEnd - L + 1;//计算元素总个数
							   //如果两边都没到终点，那么选取小的那个优先放入中间数组
	while (L <= LeftEnd && R <= RightEnd)
	{
		if (arry[L] <= arry[R]) temp[tmp++] = arry[L++];
		else
		{
			temp[tmp++] = arry[R++];
		}
	}
	while (L <= LeftEnd)//如果左边还没到终点
		temp[tmp++] = arry[L++];
	while (R <= RightEnd)//如果右边还没到终点
		temp[tmp++] = arry[R++];
	//从尾巴向前把值赋值会arry数组里，赋值多少次呢？赋值M次
	//for (int i = 0; i < Num; i++, RightEnd--)
	//	arry[RightEnd] = temp[RightEnd];
}
//归并排序
void m_Sort(int arry[], int tmp[], int L, int RightEnd)
{
	int Center;
	if (L < RightEnd)//L == RightEnd的时候，说明只有一个元素
	{
		//分而治之
		Center = (L + RightEnd) / 2;
		m_Sort(arry, tmp, L, Center);//前半个进行排序
		m_Sort(arry, tmp, Center + 1, RightEnd);//对后半个进行排序
		Merge(arry, tmp, L, Center + 1, RightEnd);
	}
}

void Merge_Sort(int arry[],int N)
{
	Init();
	int *tmpA;
	tmpA = (int*)malloc(N * sizeof(int));
	if (tmpA != NULL)
	{
		m_Sort(arry, tmpA, 0, N - 1);
		free(tmpA);
	}
	else printf("Error:空间不足。");
}

//函数作用是在某步长下，一次从头到尾的归并
void Merge_pass(int arry[],int tmp[],int N,int length)
{
	int i,j;
	//i + length * 2 < N;已经不够做一次完整的两边等长的归并
	for (i = 0; i + length * 2 < N; i += 2*length)
	{
		// i, i + length,i + 2*length -1，分别是头，中间，尾巴
		Merge(arry, tmp, i, i + length,i + 2*length -1 );
	}
	//破坏循环的条件是已经不能做等长的归并，那么应该做一次从当前到最后的归并。
	//比如前面是4个和4个归并，那最后一个可能是4个和3个的归并
	if (i + length < N)
		Merge(arry, tmp, i, i + length, N - 1);
	//前面是4个和四个的归并，那很可惜，这里连四个都没有，所以直接末尾保留
	else
	{
		for (j = i; j < N; j++)	tmp[j] = arry[j];
	}
}
//函数作用是对整个数组进行若干次变步长的归并
void Merge_Sort2(int arry[], int N)
{
	Init();
	int length = 1;
	int *tmpA;
	tmpA = (int*)malloc(N * sizeof(int));
	if (tmpA != NULL)
	{
		while (length < N)
		{
			Merge_pass(arry, tmpA, N, length);
			length *= 2;
			//Merge_pass(tmpA, arry, N, length);
			//length *= 2;
		}
		free(tmpA);
	}
	else printf("Error:空间不足。");

}
void swap(int a[], int i,int j)
{
	int temp;
	temp = a[i]; a[i] = a[j]; a[j] = temp;
}

void swap1(int a,int b)
{
	int temp;
	temp = a; a = b; b = temp;
}


//快速排序
void QuickSort(int arry[],int left,int right)
{
	int i, last;
	if (left >= right) return;

	swap(arry, left, (left + right) / 2);//把左边调整到中间
	//last始终指向要被准备被换的那个元素的前一个
	last = left;

	for (i = left + 1; i <=right; i++)
	{
		if (arry[i] < arry[left])
			swap(arry, ++last, i);
		//比枢纽点小，就自己跟自己换
		//比枢纽点大，last就不动，停在上一个比枢纽点小的位置上
		//直到再发现一个比枢纽点小的，那就last后移一位，恰好是比枢纽点大的
		//恰好实现小的和大的一次交换
		//last最后指向的是最后一个比枢纽点小的
		//所以把枢纽点和last替换，last的位置就是枢纽点应该待的位置
	}
	swap(arry, left, last);
	QuickSort(arry, left, last - 1);
	//检查枢纽点前面的集合
	QuickSort(arry, last + 1, right);
	//检查枢纽点后面的集合
	//为什么last不用变?因为last就在它最终应该在的位置上
}

void Quick_Sort(int arry[],int N)
{
	QuickSort(arry, 0, N - 1);
}

int main()
{
	Init();
	Print();
	Insert_Sort(arry, MAXSIZE);
	printf("插入排序的结果是————————————\n");
	Print();
	Shell_Sort(arry, MAXSIZE);
	printf("希尔排序的结果是————————————\n");
	Print();
	Heap_Sort(arry, MAXSIZE);
	printf("堆排序的结果是————————————\n");
	Print();
	int ans[MAXSIZE];
	Merge_Sort(arry, MAXSIZE);
	printf("递归归并排序的结果是————————————\n");
	Print();
	Merge_Sort2(arry, MAXSIZE);
	printf("非递归归并排序的结果是————————————\n");
	Print();
	Init();
	Quick_Sort(arry, MAXSIZE);
	printf("快速排序的结果是————————————\n");
	Print();
	return 0;
}

Sonihr
关注
专栏目录
数据结构——排序 笔记合集（C语言）完结
Zyairelu's blog
06-06 1万+
文章中其实有很多图来帮助理解，但是因为外链的原因，我电脑上的图不能直接拉过来，要完整版的可以评论我直接发PDF版本。因为笔记的原因没有英文注释代码，个人笔记，仅供参考。 排序排序排序算法的评估指标排序算法的分类插入排序算法效率分析优化——折半插入排序希尔排序（Shell Sort）算法性能分析冒泡排序算法性能分析快速排序算法效率分析简单选择排序算法性能分析堆排序堆的定义建立大根堆基于大根堆进行排序算法效率分析堆——插入删除归并排序（Merge Sort）算法效率分析 排序 排序算法的评估指标 算法的稳定性：
数据结构——排序（二）
qq_43965574的博客
03-09 293
排序（二）
数据结构-各种排序完整示例程序
06-29
数据结构课程中的各种排序示例完整程序，用C语言实现 各种示例包括：希尔排序、选择排序、插入排序、冒泡排序、快速排序等
八大排序(C语言)
热门推荐
顾南怀
11-01 3万+
void BubbleSort();//冒泡 void SelectSort();//选择 void InsertSort();//直接插入 void ShellSort();//希尔 void HeapSort();//堆排 void QuickSort();//快排 void MegerSort();//归并 void RadixSort();//基数(桶排序) 冒泡： 1）...
各种排序算法大合集
A_scholar的博客
10-28 572
各种算法的比较： 快速排序： 希尔(Shell)排序： 要点 希尔(Shell)排序又称为缩小增量排序，它是一种插入排序。它是直接插入排序算法的一种威力加强版。 希尔排序的基本思想是： 把记录按步长 gap 分组，对每组记录采用直接插入排序方法进行排序。 随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到 1 时，整个数据合成为一组，构成一组有序记录，则完成排序。 我们来通过演示...
八大排序【C语言】
01-25
对八大排序算法进行总结，运用C语言进行编程演示。 通过源代码及运行结果分析，比较各大排序算法的优缺点。
C语言数据结构——排序类算法
h2608011009的博客
06-01 490
文章目录前言基于插入的排序算法直接插入排序希尔排序基于选择的排序算法直接选择排序堆排序冒泡排序分治类排序算法快速排序归并排序计数排序（非比较排序） 前言 这几天耗费了大量的时间去理清排序类算法的实现以及复杂度，对排序也算是略懂一二，下面博主就进行详细的介绍算法的思路与实现过程的代码。 基于插入的排序算法 这一类算法类似于，有序的整理扑克牌，将牌不断插入从而形成有序的牌堆。 插入类排序与之类似，其主要分为直接插入排序以及衍生出来的希尔排序。 直接插入排序 使用最后一个元素与其数组其他元素通过遍历比较，找到需
数据结构（C语言实现）——堆栈
hqf1396542489的博客
10-04 4730
数据结构（C语言实现）——堆栈 在数据结构中，存在着堆栈。 堆栈其实是两种数据结构，一种是堆，一种是栈； 1.堆：堆可以被看成是一棵树，是利用完全二叉树来存储一组数据。 2.栈：一种先进后出的数据结构。 我们通常意义上说的堆栈就是指栈。 栈有先进后出的特点，即是指在读取数据时，先存储的数据后读取。 栈有两种重要的操作，入栈push，出栈pop 栈函数功能如下： 1.初始化 2.销毁 3.入栈、出栈...
c语言 数据结构——归并排序
Akun_H的博客
11-27 566
基本思想 将两个有序子序列合并，得到一个完全有序的序列，即先使每个子序列有序，再使子序列段间有序，再将两个有序表合并成一个有序表。 void _MergeSort(int* a, int left, int right, int* tmp) { if (left >= right) return; int mid = (left + right) / 2; // [left, mid] [mid+1, right] 有序 _MergeSort(a, left, mid, tmp);
C语言的八大排序详细
01-17
八大排序的详解、代码、例题、图解，各种排序的算法比较和用法。
c++八大排序算法
10-27
算法及讲解，供初学者参考，附加程序，可以自动动手试验，可用。
八大排序算法C/C++实现
09-11
八大排序算法C/C++实现
八大排序算法代码（C++）
06-09
冒泡排序，插入排序，选择排序，希尔排序，归并排序，快速排序，堆排序，拓扑排序，桶排序，基数排序
C语言实现排序算法之归并排序详解
12-25
排序算法中的归并排序(Merge Sort)是利用”归并”技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 一、实现原理： 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。 （1）合并过程 合并过程中，设置i，j和p三个指针，其初值分别指向这三个记录区的起始位置。合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[p]中，然后将被复制记录的指针i或j加1，以及指向复制位置
经典数据结构算法c语言实现代码（大全）
12-11
二叉排序树.txt 二叉树.txt 二叉树实例.txt 二进制数.txt 二进制数2.txt 余弦曲线.txt 余弦直线.txt 傻瓜递归.txt 冒泡排序.txt 冒泡法改进.txt 动态计算网络最长最短路线.txt 十五人排序.txt 单循环...
数据结构C语言排序方法-堆排序详解！.pdf
最新发布
01-15
【数据结构】C语言排序方法——堆排序详解 堆排序是一种基于比较的排序算法，它利用了二叉堆这一数据结构的特点。堆是一种特殊的树形数据结构，形状近似完全二叉树，同时满足堆积性质：在最大堆中，每个父节点的值...
(C语言)八大排序之：插入排序、冒泡排序、选择排序
trb331617的博客
01-14 309
1 /* 2 * FILE: p198_sort.c 3 * DATE: 20180114 4 * -------------- 5 */ 6 7 #include 8 9 /* 从小到大 排序 */ 10 void insert_sort_min(int *array, int length); 11 void bubble_sort(int
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值