【数据结构】排序（下）

news2024/11/25 4:22:07

在这里插入图片描述
个人主页~
排序（上）
栈和队列

排序

  • 二、常见排序的实现
    • 8、快速排序的优化
    • 9、非递归快速排序
      • （1）基本思想
      • （2）代码实现
      • （3）时间复杂度
      • （4）空间复杂度
    • 10、归并排序
      • （1）基本思想
      • （2）代码实现
      • （3）时间复杂度
      • （4）空间复杂度
    • 11、非递归归并排序
      • （1）基本思想
      • （2）代码实现
      • （3）时间复杂度
      • （4）空间复杂度
    • 12、非比较排序
      • （1）基本思想
      • （2）代码实现
      • （3）时间复杂度
      • （4）空间复杂度
  • 三、各个排序方法所用时间的比较
    • 1、代码实现
    • 2、分析
  • 四、各个排序的稳定性
    • 1、基本概念
    • 2、各个排序的稳定性复杂度一览表

二、常见排序的实现

8、快速排序的优化

当我们使用快速排序时，最坏的情况就是数组有序，此时的时间复杂度为O(N^2)
最好的情况就是key每次取中位数
所以我们为了避免最坏情况的发生，我们在快速排序的基础上衍生了一种优化的方法叫做三数取中
还有一种方法是随机选key，但随机选key的效果不如三数取中

int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] < a[right])
			return right;
		else
			return left;
	}
	else
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
}

将三个比较出中间的数字作为key然后换到left上，进行partsort
在每个partsort的最前边加上这条语句，就优化了这个快速排序的结构

int PartSort(int* a, int left, int right)
{
	int midi = GetMidIndex(a, left, right);
	Swap(&a[left], &a[midi]);
	......
}

9、非递归快速排序

（1）基本思想

前边我们讲的快速排序是基于递归条件下实现的，但我们知道，递归会消耗栈上的空间，并且栈上的空间比较小，不能实现大量数据的快速排序，所以我们要将这个过程放在空间更大的堆上，也就是使用栈来实现
栈的作用就是存储区间，这个区间由两个整数组成，通过出入栈来模拟递归的过程

（2）代码实现

这里需要包含一下以前我们写过的栈的头文件

void QuickSortNonR(int* a, int left, int right)
{
	Stack st;
	StackInit(&st);
	StackPush(&st,right);
	StackPush(&st, left);

	while (!StackEmpty(&st))
	{
		int left = StackTop(&st);
		StackPop(&st);
		int right = StackTop(&st);
		StackPop(&st);
        //取出区间
        
		int keyi = PartSort1(a, left, right);
		//通过keyi将数据区间一分为二
		
		if (keyi + 1 < right)
		{
			StackPush(&st, right);
			StackPush(&st, keyi + 1);
		}
		if (left < keyi - 1)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, left);
		}
		//存入区间
	}
	StackDestroy(&st);
}

在这里插入图片描述

（3）时间复杂度

同递归方式的快速排序，为O(log₂N * N)

（4）空间复杂度

同递归方式的快速排序，为O(log₂N)

10、归并排序

（1）基本思想

将一个待排序的序列分为若干个子序列，每个子序列都是有序的，然后再将有序的序列合并为整体的有序序列

（2）代码实现

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left == right)
		return;
	
	//找到中间下标
	int midi = (left + right) / 2;
	
	//一分为二二分为四的分开
	_MergeSort(a, left, midi, tmp);
	_MergeSort(a, midi + 1, right, tmp);
	
	int begin1 = left, end1 = midi;
	int begin2 = midi + 1, end2 = right;
    
    //i用来记录容器数组中对应的下标
	int i = left;
	
	//将两个数组中按升序归并到容器数组中
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
			tmp[i++] = a[begin1++];
			
		else
			tmp[i++] = a[begin2++];
	}
  
    //如果左右两个区间的数字还没有全部入到容器数组中，将它们按顺序输入
	while (begin1 <= end1)
		tmp[i++] = a[begin1++];
	while (begin2 <= end2)
		tmp[i++] = a[begin2++];

    //将容器数组复制到原来的数组上
	memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

在这里插入图片描述

（3）时间复杂度

归并排序分为两个过程
一是分解过程，这是一个类二叉树的过程，由中间下标分为两个区间，再分为四个区间，以此类推，此过程的时间复杂度是O(log₂N)
二是合并过程，合并过程中需要遍历整个数组，找到谁大谁小然后排序，这个过程的时间复杂度是O(N)
整个过程的时间复杂度就是O(N*log₂N)

（4）空间复杂度

该过程需要在堆上开辟n个空间，以及递归所需要的log₂n个在栈上的空间，由于对于n来说log₂n很小，所以它的空间复杂度为O(N)

11、非递归归并排序

（1）基本思想

与快速排序相同，递归方式的归并排序需要使用栈中空间，在处理大量数据时空间不够，所以我们可以用循环的方法减少栈的使用，这就是非递归的归并排序

（2）代码实现

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	int gap = 1;
	while (gap < n)
	{
		int j = 0;//作为tmp的下标
		for (int i = 0; i < n; i += 2*gap)//每次跳过两组数据
		{
	    	//这里的间隔差gap，每次比较两组数据
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + gap * 2 - 1;
		
			//以下同上
			if (end1 >= n || begin2 >= n)
				break;
			if (end2 >= n)
				end2 = n - 1;
				
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
					tmp[j++] = a[begin1++];
				else
					tmp[j++] = a[begin2++];
			}
			
			while (begin1 <= end1)
				tmp[j++] = a[begin1++];
			while (begin2 <= end2)
				tmp[j++] = a[begin2++];
				
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		gap *= 2;//while结束后把间隔调两倍
	}
	free(tmp);
}

在这里插入图片描述

（3）时间复杂度

for循环每次gap*=2，时间复杂度为O(log₂N)，for循环中遍历了一遍数组，时间复杂度为O(N)
总的时间复杂度为O(N * log₂N)

（4）空间复杂度

申请了堆上的n个空间，空间复杂度为O(N)

12、非比较排序

（1）基本思想

计数排序是一种非比较排序，实现过程中不需要任何的比较
第一步：统计相同元素出现的次数
第二步：根据统计的结果将序列回收到原来的序列当中
这个排序适用于数据比较集中的序列

（2）代码实现

void CountSort(int* a, int n)
{
	int min, max;
	min = max = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	int range = max - min + 1;
	//找到这一组数据中最大和最小的数相减得出这组数据的范围
	int* countA = (int*)malloc(sizeof(int) * range);
	memset(countA, 0, sizeof(int)*range);
	//创建一个在堆上的数组作为计数数组，大小为这组数据的范围，将其中的元素全部重置为0
	for (int i = 0; i < n; i++)
		countA[a[i] - min]++;
	//将每个数字出现的次数记录
	int k = 0;
	for (int i = 0; i < range; i++)
	{
		while (countA[i]--)
			a[k++] = i + min;
	}
}//下标加上整个数组的最小值就是当前数据的大小，countA为0时退出循环，不为0就记录下来

在这里插入图片描述

（3）时间复杂度

找出最大最小值需要遍历一遍数组，记录数字走for循环中range
所以时间复杂度为O(N+range），当数据比较集中时，时间复杂度接近O(N)
到底是O(N）还是O(range）取决于它们俩哪个大

（4）空间复杂度

在堆上开辟了range个空间，空间复杂度为O(range），当数据比较集中时，空间复杂度接近O(1)

三、各个排序方法所用时间的比较

1、代码实现

void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);
	int* a8 = (int*)malloc(sizeof(int) * N);


	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();//取随机值
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
		a8[i] = a1[i];
		//赋值给所有数据
	}

	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();
//clock是一个函数，用于记录当前时间点，在开始时记录一下，在结束后记录一下
//得出的时间差就是这个排序所用的时间
	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	int begin3 = clock();
	BubbleSort(a3, N);
	int end3 = clock();

	int begin4 = clock();
	SelectSort(a4, N);
	int end4 = clock();

	int begin5 = clock();
	HeapSort(a5, N);
	int end5 = clock();

	int begin6 = clock();
	QuickSort(a6, 0, N - 1);
	int end6 = clock();

	int begin7 = clock();
	MergeSort(a7, N);
	int end7 = clock();

	int begin8 = clock();
	CountSort(a8, N);
	int end8 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("BubbleSort:%d\n", end3 - begin3);
	printf("SelcetSort:%d\n", end4 - begin4);
	printf("HeapSort:%d\n", end5 - begin5);
	printf("QuickSort:%d\n", end6 - begin6);
	printf("MergeSort:%d\n", end7 - begin7);
	printf("CountSort:%d\n", end8 - begin8);

	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
	free(a7);
	free(a8);
}

2、分析

在这里插入图片描述
当数据给到10W个时，我们可以明显看出各个排序的差距
最拉胯的就是冒泡排序，跟其他排序所用时间都不在一个量级上
然后就是直接插入以及选择插入
然后就是希尔排序、堆排序、快速排序、归并排序
因为随机数的生成是由时间戳实现的，两个随机数之间差的并不多，所以范围比较集中，这就使得计数排序超级快

四、各个排序的稳定性

1、基本概念

稳定性好就是一个序列中存在着两个即两个以上的相同数据，这两个数据在排序前后相对位置不变，反之就是不好
这里的前后相对位置不变不是指它们两个数据一直待在原来的位置，而是前边的数字a1在排列后还在后边的数字a2前边，而不是跑到它的后边了

2、各个排序的稳定性复杂度一览表

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(N^2)O(N)O(N^2)O(1)稳定
简单选择排序O(N^2)O(N^2)O(N^2)O(1)不稳定
直接插入排序O(N^2)O(N)O(N^2)O(1)稳定
希尔排序O(N ^log₂N)~O(N ^2)O(N^1.3)O(N^2)O(1)不稳定
堆排序O(N^log₂N)O(N^log₂N)O(N^log₂N)O(1)不稳定
归并排序O(N^log₂N)O(N^log₂N)O(N^log₂N)O(N)稳定
快速排序O(N^log₂N)O(N^log₂N)O(N^2)O(log₂N)~O(N)不稳定

感谢观看
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1830132.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

第二篇： 掌握Docker的艺术：深入理解镜像、容器和仓库

第二篇： 掌握Docker的艺术：深入理解镜像、容器和仓库

掌握Docker的艺术&#xff1a;深入理解镜像、容器和仓库 1. 引言 1.1 简要介绍Docker的重要性 在当今快速发展的技术世界中&#xff0c;软件开发和部署的效率和可靠性是衡量成功的关键因素。Docker&#xff0c;作为一个开源的容器化平台&#xff0c;革新了软件的打包、分发和…
阅读更多...
016基于SSM+Jsp的医院远程诊断系统

016基于SSM+Jsp的医院远程诊断系统

开发语言&#xff1a;Java框架&#xff1a;ssm技术&#xff1a;JSPJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包…
阅读更多...
知识普及:什么是边缘计算（Edge Computing）？

知识普及:什么是边缘计算（Edge Computing）？

边缘计算是一种分布式计算架构&#xff0c;它将数据处理、存储和服务功能移近数据产生的边缘位置&#xff0c;即接近数据源和用户的位置&#xff0c;而不是依赖中心化的数据中心或云计算平台。边缘计算的核心思想是在靠近终端设备的位置进行数据处理&#xff0c;以降低延迟、减…
阅读更多...
如何看懂SparkUI?

如何看懂SparkUI?

Jobs页面 Stage页面 显示额外的指标和摘要指标&#xff1a; 摘要指标&#xff08;Summary Metrics&#xff09;统计了所有完成的任务的执行行为&#xff0c;包括执行时间、GC时间、输入输出信息等&#xff0c;并提供了最小值&#xff08;Min&#xff09;、第25百分位数&#xf…
阅读更多...
Windows环境利用 OpenCV 中 CascadeClassifier 分类器识别人脸 c++

Windows环境利用 OpenCV 中 CascadeClassifier 分类器识别人脸 c++

Windows环境中配置OpenCV 关于在Windows环境中配置opencv的说明&#xff0c;具体可以参考&#xff1a;VS2022 配置OpenCV开发环境详细教程。 CascadeClassifier 分类器 CascadeClassifier 是 OpenCV 库中的一个类&#xff0c;它用于实现一种快速的物体检测算法&#xff0c;称…
阅读更多...
Java面向对象-final关键字

Java面向对象-final关键字

Java面向对象-final关键字 一、final1、修饰变量2、修饰方法3、修饰类4、案例 一、final 可以修饰变量、方法、类 1、修饰变量 final修饰一个变量&#xff0c;变量的值不可以改变&#xff0c;这个变量就变成一个字符常量&#xff0c;约定俗称的规定&#xff1a;名字大写。 f…
阅读更多...
基于ChatGPT的大型语言模型试用心得

基于ChatGPT的大型语言模型试用心得

近年来&#xff0c;ChatGPT这样的大型语言模型&#xff0c;它如同一颗冉冉升起的新星&#xff0c;迅速在商业、教育、娱乐等多个领域照亮了创新的天空&#xff0c;极大地革新了我们的工作与日常生活。 最近我发现一些国内用户也能自由访问的中文ChatGPT APP。这个平台不仅提供…
阅读更多...
python-pip配置镜像源加速下载Python包安装：快速配置pip源-国内加速源

python-pip配置镜像源加速下载Python包安装：快速配置pip源-国内加速源

&#x1f308;所属专栏&#xff1a;【pip】✨作者主页&#xff1a; Mr.Zwq✔️个人简介&#xff1a;一个正在努力学技术的Python领域创作者&#xff0c;擅长爬虫&#xff0c;逆向&#xff0c;全栈方向&#xff0c;专注基础和实战分享&#xff0c;欢迎咨询&#xff01; 您的点赞…
阅读更多...
struts2框架漏洞

struts2框架漏洞

title: struts2框架漏洞 categories: 漏洞复现 abbrlink: 48203 date: 2024-06-14 15:45:27 前言知识 ognl表达式注入 对象导航图语言&#xff0c;用于访问对象的字段、方法。基于简化访问java对象属性和调用方法需求&#xff0c;实现字段类型转化等功能&#xff1b;访问列表…
阅读更多...
基于Matlab的BP神经网络的车牌识别系统（含GUI界面）【W7】

基于Matlab的BP神经网络的车牌识别系统（含GUI界面）【W7】

简介&#xff1a; 本系统结合了图像处理技术和机器学习方法&#xff08;BP神经网络&#xff09;&#xff0c;能够有效地实现车牌的自动识别。通过预处理、精确定位、字符分割和神经网络识别&#xff0c;系统能够准确地识别各种车牌图像&#xff0c;并在智能交通管理、安防监控等…
阅读更多...
Java | Leetcode Java题解之第155题最小栈

Java | Leetcode Java题解之第155题最小栈

题目&#xff1a; 题解&#xff1a; class MinStack {Deque<Integer> xStack;Deque<Integer> minStack;public MinStack() {xStack new LinkedList<Integer>();minStack new LinkedList<Integer>();minStack.push(Integer.MAX_VALUE);}public void …
阅读更多...
java问题解决： IDEA java 警告 源发行版 17 需要目标发行版 17

java问题解决： IDEA java 警告 源发行版 17 需要目标发行版 17

效果图 问题原因 jdk和你实际安装的jdk不匹配 解决问题 1.点击File -->Project Structure–>Project 修改这两处 2. 在Project Structure–>Modules中的红框位置都要调整对应版本 3、点击File–>settings–>java compile将对应框的版本修改成对应版本即可–改…
阅读更多...
Docker的基本操作 及 容器与外部机互相通讯（持续更新中）

Docker的基本操作 及 容器与外部机互相通讯（持续更新中）

Docker入门&#xff1a; Docker 入门教程 - 阮一峰的网络日志 (ruanyifeng.com)docker入门&#xff0c;这一篇就够了。-CSDN博客Docker 容器使用 | 菜鸟教程 (runoob.com)Docker自定义网络和运行时指定IP_docker run ip-CSDN博客 基本命令 链接&#xff1a;docker入门&#…
阅读更多...
MVC 框架安全

MVC 框架安全

在现代 Web 开发中&#xff0c;使用 MVC 架构是一种流行的做法。MVC 是 Model-View-Controller 的缩写&#xff0c;它将 Web 应用分为三层&#xff0c;View 层负责用户视图、页面展示等工作&#xff1b;Controller 负责应 用的逻辑实现&#xff0c;接收 View 层传入的用户请求&…
阅读更多...
Luma AI如何注册：文生视频领域的新星

Luma AI如何注册：文生视频领域的新星

文章目录 Luma AI如何注册&#xff1a;文生视频领域的新星一、Luma 注册方式二、Luma 的效果三、Luma 的优势四、Luma 的功能总结 Luma AI如何注册&#xff1a;文生视频领域的新星 近年来&#xff0c;Luma AI 凭借其在文生视频领域的创新技术&#xff0c;逐渐成为行业的新星。…
阅读更多...
【如何保持专注】

【如何保持专注】

今日&#x1f4d2;&#xff0c;看博主分享下保持专注的新方法&#xff0c;有点意思 &#xff0c; 怎么保持专注&#xff0c;给大家分享两个极客的方法啊。 第一个呢是来自于一个非常著名的程序员啊&#xff0c;叫做这个尼克温特&#xff0c;大家有兴趣可以查一下&#xff0c;就…
阅读更多...
Linux源码学习笔记01-Linux内核源码结构

Linux源码学习笔记01-Linux内核源码结构

Linux内核特性 是一个类Unix操作系统&#xff0c;但不是简化的Unix&#xff1b;不仅继承了Unix的特征&#xff0c;还有其他特性。 Linux内核的组织形式&#xff1a;整体式的结构&#xff0c;方便每个领域的开发人员参与开发&#xff1b;Linux进程调度方式简单高效&#xff1a…
阅读更多...
结构设计模式 - 桥接设计模式 - JAVA

结构设计模式 - 桥接设计模式 - JAVA

桥接设计模式 一. 介绍二. 桥接模式示例2.1 定义实现部分和具体实现2.2 定义抽象部分和细化抽象部分2.3 测试2.4 解释 三. 结论 前言 这是我在这个网站整理的笔记,有错误的地方请指出&#xff0c;关注我&#xff0c;接下来还会持续更新。 作者&#xff1a;神的孩子都在歌唱 一.…
阅读更多...
串口触摸屏分割字符串

串口触摸屏分割字符串

分割字符串的方法1、split2、indexOf()3、substr(start,length) 分割字符串的方法 1、split&#xff1a;将一个字符串分割为子字符串&#xff0c;然后将结果作为字符串数组返回。 2、indexOf() &#xff1a;返回某个指定的字符串值在字符串中首次出现的位置&#xff08;从左向右…
阅读更多...
Vue55-TodoList案例-本地存储

Vue55-TodoList案例-本地存储

一、TodoList案例-本地存储 此时&#xff0c;修改对象里面的属性&#xff0c;watch监视不到&#xff01; 需要深度监视&#xff0c;就不能用简写形式&#xff01; 二、jeecg-boot中的本地存储 jeecg-boot中&#xff0c;浏览器的本地存储&#xff0c;存储的是token&#xff01;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023