算法---八大排序

最新推荐文章于 2024-08-03 16:34:23 发布
最新推荐文章于 2024-08-03 16:34:23 发布
阅读量77 收藏
点赞数 1
分类专栏： 数据结构 笔记 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48983250/article/details/121369251
版权

算法

1.冒泡排序

//冒泡排序
//时间复杂度O（n^2） 
//空间复杂度O（1）
//稳定性：稳定
void Swap(int* ap, int* bp)
{
	assert(ap != NULL && bp != NULL);
	if (*ap > *bp)
	{
		int tmp = *ap;
		*ap = *bp;
		*bp = tmp;
	}
}
void BubbleSort(int* arr, int len)
{
	assert(arr != NULL);
	int i = 0, j = 0;
	for (i = 0; i < len; ++i)
	{
		for (j = 0; j < len - 1-i; ++j)
		{
			Swap(&arr[j], &arr[j + 1]);
		}
	}
}
int Print(int *arr, int len)
{
	assert(arr != NULL);
	BubbleSort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}
int main()
{
	int arr[] = { 2,32,4,45,29,56,43,81,7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);
	return 0;
}

2.简单选择排序

//简单选择排序
//每一轮找到待排序序列的最小值和待排序序列的第一个值进行交换
//时间复杂度O（n^2）
//空间复杂度O（1）
//稳定性：不稳定
void SelectSort(int* arr, int len)
{
	assert(arr != NULL);
	int minindex;//保存最小值的下标，而不是最小值本身
	for(int i = 0; i < len - 1; ++i)//控制层数
	{
		minindex = i;
		for (int j = i + 1; j < len; ++j)//找到这一轮待排序序列的最小值的下标
		{
			if (arr[j] < arr[minindex])
			{
				minindex = j;
			}
		}
		//第二层for循环执行结束，可以确定待排序序列中最小值的下标，保存在minindex里面
		if (minindex != i)
		{
			int tmp = arr[minindex];
			arr[minindex] = arr[i];
			arr[i] = tmp;
		}
	}
}
int Print(int *arr, int len)
{
	assert(arr != NULL);
	SelectSort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}
int main()
{
	int arr[] = { 2,1,3,9,8,7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);
	return 0;
}

3.直接插入排序

//直接插入排序
//依次从待排序序列中取值，向已排序序列中放，保证再次完全有序，直到将待排序序列中所有值取完
///时间复杂度O（n^2）  
//空间复杂度O（1）  
//稳定性：稳定
void InsertSort(int* arr, int len)
{
	int tmp = 0;
	int j;//j代表的是已排序序列中需要和tmp比较的值
	for (int i = 1; i <= len - 1; ++i)
	//i代表的是未排序序列中此次需要插入的值（变稳定）
	{
		tmp = arr[i];
		for (j = i - 1; j >= 0; --j)
		//j代表的是已排序序列中需要和tmp比较的值
		{
			if (arr[j] > tmp)
			{
				arr[j + 1] = arr[j];
			}
			else
			{
				break;
			}
		}
		arr[j + 1] = tmp;
	}
}
int Print(int *arr, int len)
{
	assert(arr != NULL);
	InsertSort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}
int main()
{
	int arr[] = { 9,7,10,2,5,12,6,99,55,3,2,6,5,21 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);
	return 0;
}

4.希尔排序

//希尔排序
//shell排序，缩小增量排序，对于直接插入排序的优化，每一次让数据变得更加稳定，直到增量为1的时候，彻底完全有序
//时间复杂度O（n^1.3~1.5）
//空间复杂度O（1）
//稳定性：不稳定
void Shell(int* arr, int len, int gap)
{
	int tmp = 0;
	int j;//j代表的是已排序序列中需要和tmp比较的值
	for (int i = gap; i < len; ++i)
	{
		tmp = arr[i];
		for (j = i - gap; j >= 0; j -= gap)
		{
			if (arr[j] > tmp)
			{
				arr[j + gap] = arr[j];
			}
			else
			{
				break;
			}
		}
		//此时内层for退出，代表着tmp最终的位置已经找到
		arr[j + gap] = tmp;
	}
}
void ShellSort(int* arr, int len)
{
	int brr[] = { 13,11,7,5,3,1 };
	int len_brr = sizeof(brr) / sizeof(brr[0]);
	for (int i = 0; i < len_brr; ++i)
	{
		Shell(arr, len, brr[i]);
	}
}
int Print(int *arr, int len)
{
	assert(arr != NULL);
	ShellSort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}
int main()
{
	int arr[] = { 9,7,10,2,5,12,6,99,55,3,2,6,5,21 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);
	return 0;
}

5.堆排序

//堆排序，如果需要升序排序，则需要大顶堆，则将去数据调整为大顶堆，再将根节点和最后一个节点交换数据
//时间复杂度：O(nlogn)(以2为底的n)
//空间复杂度O(n)
//稳定性：不稳定
//调整一次大顶堆
void AdjustHeap(int arr[], int start, int end)
{
	int tmp = arr[start];
	int i = start;
	int j = 2 * i + 1;
	for (j; j <= end; j = 2 * i + 1)
	{
		if (j<end && arr[j + 1]>arr[j])
		{
			j++;
		}

		if (arr[j] > tmp)
		{
			arr[i] = arr[j];
			i = j;
		}
		else
		{
			break;
		}
	}
	arr[i] = tmp;

}

void HeapSort(int* arr, int len)
{
	//最后一个叶子节点len-1,最后一个非叶子节点的下标为（(len-1)-1)/2
	//初始状态下，调整大顶堆需要，从最后一个非叶子节点开始，从后向前，从下向上调整

	for (int i = (len-1-1)/2;i>=0;--i)
	{
		AdjustHeap(arr, i, len - 1);
		//第三个参数，找不到规则，直接填最大下标位置即可（饱和时救援）
	}
	//此时for循环执行结束，初始状态下最繁琐的调整大顶堆搞定
	for (int i = 0; i < len - 1; ++i)//轮数
	{
		int tmp = arr[0];//交换的是根节点arr[0]，而不是arr[i]
		arr[0] = arr[len - 1 - i];
		arr[len - 1-i] = tmp;
		AdjustHeap(arr, 0, (len-1-i)-1);
	}

}

6.基数排序


```c
//基数排序（桶排序）
//时间复杂度：O(dn)
//空间复杂度：O(dn)
//稳定性：稳定
int Get_Fignure_Max(int* arr, int len)
{
	int max = arr[0];
	for (int i = 1; i < len; ++i)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	int count = 0;
	while (max != 0)
	{
		count++;
		max /= 10;
	}
	return count;
}
int Get_Num(int n, int index)
{
	for (int i = 0; i < index; ++i)
	{
		n = n / 10;

	}
	return n % 10;

}
static void Radix(int* arr, int len,int index)
{
	int brr[10][20];//申请的0-9号桶
	int crr[10] = { 0 };//用crr[i]里的值代表对应的i号桶里面有多少个值
	for (int i = 0; i < len; ++i)
	{
		int tmp = Get_Num(arr[i],index);//tmp保存着值arr[i[应该放的桶号
		brr[tmp][crr[tmp]++] = arr[i];

	}
	int k = 0;
	for (int i = 0; i <= 9; ++i)//桶号
	{
		for (int j = 0; j < crr[i]; ++j)
		{
			arr[k++] = brr[i][j];
		}
	}

}
void Radix_Sort(int* arr, int len)
{
	int count = Get_Fignure_Max(arr, len);
	for (int i = 0; i < count; ++i)
	{
		Radix(arr, len,i);//i=0以个位排序一次，i=1以十位排序一次，
	}
}
int Print(int* arr, int len)
{
	assert(arr != NULL);
	Radix_Sort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}
int main()
{
	int arr[] = { 7,5,23,4,67,45,66,99,54 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Print(arr, len);
	return 0;
}

标题7.堆排序

//堆排序，如果需要升序排序，则需要大顶堆，则将去数据调整为大顶堆，再将根节点和最后一个节点交换数据
//时间复杂度：O(nlogn)(以2为底的n)
//空间复杂度O(n)
//稳定性：不稳定
//调整一次大顶堆
void AdjustHeap(int arr[], int start, int end)
{
	int tmp = arr[start];
	int i = start;
	int j = 2 * i + 1;
	for (j; j <= end; j = 2 * i + 1)
	{
		if (j<end && arr[j + 1]>arr[j])
		{
			j++;
		}
		if (arr[j] > tmp)
		{
			arr[i] = arr[j];
			i = j;
		}
		else
		{
			break;
		}
	}
	arr[i] = tmp;
}

void HeapSort(int* arr, int len)
{
	//最后一个叶子节点len-1,最后一个非叶子节点的下标为（(len-1)-1)/2
	//初始状态下，调整大顶堆需要，从最后一个非叶子节点开始，从后向前，从下向上调整
	for (int i = (len-1-1)/2;i>=0;--i)
	{
		AdjustHeap(arr, i, len - 1);
		//第三个参数，找不到规则，直接填最大下标位置即可（饱和时救援）
	}
	//此时for循环执行结束，初始状态下最繁琐的调整大顶堆搞定
	for (int i = 0; i < len - 1; ++i)//轮数
	{
		int tmp = arr[0];//交换的是根节点arr[0]，而不是arr[i]
		arr[0] = arr[len - 1 - i];
		arr[len - 1-i] = tmp;
		AdjustHeap(arr, 0, (len-1-i)-1);
	}
}

8.快速排序

//快速排序:重复划分，找基准值，将小于基准值的值全部放在左边，大于基准值的值全部放在右边：从右向左找比arr[left]更小的值，再从左向右找比arr[left]更大的值放过去，重复操作，直到left>=rigth退出
//综合情况来看，是最快的，数组越乱越有序，是每一次将基准值放到合适位置上
// 时间复杂度为O(nlogn)
// 空闲复杂度O(logn)
// 稳定性：不稳定
//
int Partition(int* arr, int left, int right)
{
	int tmp = arr[left];
	while (left < right)
	{
		while (left<right && arr[right]>tmp)
		{
			right--;
		}

if (left == right)
		{
			break;
		}
		arr[left] = arr[right];
		while (left < right && arr[left] <= tmp)
		{
			left++;
		}
		if (left == right)
		{
			break;
		}
		arr[right] = arr[left];
	}
	arr[left] = tmp;
	return left;
}
void Quick(int arr[], int left, int right)
{
	if (left < right)
	{
		int index = Partition(arr, left, right);
		if (left < index - 1)//保证基准值左边至少有两个值
		{
			Quick(arr, left, index - 1);
		}
		if (index + 1 < right)
		{
			Quick(arr, index + 1, right);
		}
	}
}
void QuickSort(int* arr, int len)
{
	Quick(arr, 0, len - 1);
}
int Print(int* arr, int len)
{
	assert(arr != NULL);
	QuickSort(arr, len);
	for (int i = 0; i < len; ++i)
	{
		printf("%d  ", arr[i]);
	}
	return 0;
}
int main()
{
	int arr[] = { 9,7,10,2,5,6,12,99,55,3,2,6,5,21 };
	int n = sizeof(arr) / sizeof(arr[0]);
	Print(arr, n);
	return 0;
}

均在vs上编译通过

喝可乐的猫?
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
八大排序-java实现版
03-01
八大排序java实现版本，直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序，并有时间比较，博文...
八大排序算法
04-04
### 八大排序算法精讲 #### 一、概述 排序算法是计算机科学中的一个重要组成部分，主要用于对数据进行整理和优化。根据数据处理的方式不同，排序可以分为内部排序和外部排序两大类。内部排序指的是所有待排序的数据...
数据结构算法---八大排序
weixin_57535054的博客
05-03 2594
数据结构八大排序详细解读！
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
排序算法--Sort Algorithm
YZG ' BLOG
12-23 1300
一、排序算法的概念： 排序也称排序算法 (Sort Algorithm)，排序是将一 组数据，依指定的顺序进行排列 的过程 二、排序算法的分类： 1) 内部排序: 指将需要处理的所有数据都加载 到内部存储器中进行排序。 2) 外部排序法： 数据量过大，无法全部加载到内 存中，需要借助外部存储进行 排序 三、算法的时间复杂度 时间频度:一个算法中的语句执行次数称为语句频度或时间频度。记为T(n) 时间复杂度：一般情况下，算法中的基本操作语句的...
八大排序算法---希尔排序原理及代码
qq_37509948的博客
12-09 2537
冒泡排序 选择排序 直接插入排序 希尔排序 算法原理：（希尔排序又称缩小增量排序。） 基本思想：先将原表按增量ht分组，每个子文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分为子文件，再直接插入法排序。直到ht=1时整个文件排好序。 关键：选择合适的增量。 希尔排序算法9-3：可以通过三重循环来实现。 图解：首先每隔一定的步长，选择一组数据，每组两个数，并将其进行比较后，排序 实例分析 1.选取间隔为4 2.选取间隔为2 3.选取间隔为1 增量的选取为了更有效率出现了克努特序列。 h=h
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
八大排序算法-快速排序
大猪的博客
10-19 1172
快速排序算法的定义是： 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序算法的基本思想：   设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，...
排序和查找算法--总结
qq_36006996的博客
11-16 1356
一、分类 1.内部排序和外部排序　 内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进行的排序过程。 外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序 2.比较类排序和非比较排序 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非.
面试版-八大排序算法
我的梦
08-23 2538
整理一份适合面试的八大排序算法，参考： https://blog.csdn.net/csdn_baotai/article/details/80293679 https://blog.csdn.net/ysunflower/article/details/80425788 https://blog.csdn.net/prstaxy/article/details/81663...
常见的八大排序算法
学Java，找哪吒
02-17 1万+
目录一、算法思维导图二、算法分类三、冒泡排序1、基本思想2、动态效果图3、代码实现4、速度测试四、选择排序1、基本思想2、动态效果图3、代码实现4、速度测试五、插入排序1、基本思想2、动态效果图3、代码实现4、速度测试六、希尔排序1、基本思想2、效果图3、代码实例七、快速排序1、基本思想2、效果图3、算法描述4、代码实例5、速度测试八、归并排序1、基本思想2、效果图3、代码实现4、速度测试九、基数排序1、基本思想2、动态效果图3、代码实例4、速度测试 一、算法思维导图 二、算法分类 算法的时间复杂度和空
JavaSE-八大经典排序算法及优化算法思路与实现
如何心安理得的在老板眼皮下摸鱼
12-02 1万+
目录 1.冒泡排序 1.1算法思想 1.2 算法实现 1.3 算法改进 1.4 算法分析 2.选择排序 2.1 算法思想 2.2 算法实现 2.3 算法改进 2.4 算法分析 1.冒泡排序 1.1算法思想 冒泡排序的过程就如同它的名字一样，每次冒泡的过程会将元素中最大/小的一个数冒出来，这样最后的一个元素就会是最大/小的元素，下一次冒泡过程就可以对前n-1个再进行排序，n趟过程下来整个序列就变成有序的了。 以上图为例，它的过程如下： 比较相邻的元素。如果...
八大排序_C-C++_
10-03
**八大排序算法详解** 在计算机科学中，排序是将一组数据按照特定顺序排列的过程，而排序算法则是实现这一过程的方法。本篇文章将深入探讨八大经典的排序算法，它们分别是冒泡排序、选择排序、插入排序、希尔排序、...
数据结构-部分算法整合
03-11
本文主要涵盖了五个核心主题：最短路径问题、KMP算法、最小生成树算法、八大排序问题以及其他问题整合。 一、最短路径问题： 1. **单源最短路径**： - **BFS（广度优先搜索）**：适用于无权图，通过逐层遍历找到从...
c++八大排序算法
10-27
算法及讲解，供初学者参考，附加程序，可以自动动手试验，可用。
初识集合和数据结构
m0_51821434的博客
08-03 723
这次文章就浅浅的介绍了一下数据结构的基础知识，集合的框架，算法的一些特性
数据结构(面试)
Anterior_condyle的博客
08-01 968
在含有n个带权叶节点的二叉树中，其中带权路径（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。
2024.7.24 作业
qq_64434282的博客
07-24 3012
【代码】2024.7.24 作业。
程序设计基础(c语言)_补充_2
最新发布
renewal_m的博客
08-03 137
定义整型变量a，并输入一个整数到a，请编写程序分别按十进制，八进制和十六进制输出a的值。
八大内部排序算法详解
"这篇资料详细介绍了编程界公认的八大排序算法，包括内部排序和外部排序的概念，强调了在数据量较大时适合使用的O(nlog2n)时间复杂度的排序方法，如快速排序、堆排序和归并排序。资料中特别提到了快速排序的效率优势...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值