数据结构:排序算法之交换排序(冒泡排序、快速排序)

【HAL库】STM32CubeMX开发----STM32F407----SPI实验 阅读详情

1、冒泡

void bubbleSort(int a[], int n){
	for(int i =0 ; i< n-1; ++i) {
		for(int j = 0; j < n-i-1; ++j) {
			if(a[j] > a[j+1])
			{
				int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
			}
		}
	}
}

/*1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
改进后算法如下:
*/
void Bubble_1 ( int r[], int n) {
	int i= n -1;  //初始时,最后位置保持不变
	while ( i> 0) { 
		int pos= 0; //每趟开始时,无记录交换
		for (int j= 0; j< i; j++)
			if (r[j]> r[j+1]) {
				pos= j; //记录交换的位置 
				int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
			} 
		i= pos; //为下一趟排序作准备
	 } 
}

/*2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。
改进后的算法实现为:
*/
void Bubble_2 ( int r[], int n){
	int low = 0; 
	int high= n -1; //设置变量的初始值
	int tmp,j;
	while (low < high) {
		for (j= low; j< high; ++j) //正向冒泡,找到最大者
			if (r[j]> r[j+1]) {
				tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
			} 
		--high;					//修改high值, 前移一位
		for ( j=high; j>low; --j) //反向冒泡,找到最小者
			if (r[j]<r[j-1]) {
				tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;
			}
		++low;					//修改low值,后移一位
	} 
}


2、快速排序

#include <iostream>
#include <stack>
using namespace std;


int GetKeyIndex(int array[], int left, int right)
{
	int mid = left + ((right - left)>>1);
	if(array[left] < array[right])
	{
		if(array[mid] < array[left])
			return left;
		if(array[mid] > array[right])
			return right;
		else
			return mid;
	}
	else
	{
		if(array[mid] < array[right])
			return right;
		else if(array[mid] > array[left])
			return left;
		else
			return mid;
	}
}
 


int partion(int array[], int left, int right)
{
	int begin = left;
	int end = right-1;
	//三个数取中间
	int keyIndex = GetKeyIndex(array, left, right);
	if(keyIndex != right)
	{
		std::swap(array[keyIndex], array[right]);
	}

	int key = array[right];

	while( begin < end )
	{
		while( begin < end && array[begin] <= key)
			begin++;

		while( begin < end && array[end] > key)
			end--;

		if(begin < end)
		{
			std::swap(array[begin], array[end]);
			begin++;
		}
	}
	if(begin != right && array[begin] > array [right])
	{
		swap(array[begin], array [right]);
		return begin;
	}
	return right;
}
 

void QuickSort(int array[], int left, int right)
{

	if(left < right)
	{
	   int div = partion(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}
 
 /*
 int partion2(int array[], int left, int right)
{
	int begin = left;
	int end = right;
	////三个数取中间
	//int keyIndex = GetKeyIndex(array, left, right);
	//if(keyIndex != right)
	//{
	//	std::swap(array[keyIndex], right);
	//}
	int key = array[right];

	while( begin < end )
	{
		while( begin < end && array[begin] <= key)
			begin++;
		std::swap(array[begin], array[end]);

		while( begin < end && array[end] > key)
			end--;
		std::swap(array[begin], array[end]);
	}
	return begin;
}
 

void QuickSort(int array[], int left, int right)
{

	if(left < right)
	{
	   int div = partion2(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

int partion3(int array[], int left, int right)
{
	int begin = left;
	int end = right;
	
	int key = array[left];

	while( begin < end )
	{

		while( begin < end && array[end] >= key)
			end--;
		if(begin < end)
		{
			array[begin] = array[end];
			begin++;
		}

		while( begin < end && array[begin] <= key)
			begin++;
		if(begin < end)
		{
			array[end] = array[begin];
			end--;
		}
	}
	array[begin] = key;
	return begin;
}


void QuickSort(int array[], int left, int right)
{
	if(left < right)
	{
	   int div = partion3(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

int partion4(int array[], int left, int right)
{
	int Cur = left;
	int Prev = Cur - 1;
	
	int key = array[right];
	while(Cur <= right)
	{
		if(array[Cur] < key && ++Prev != Cur)
			std::swap(array[Prev], array[Cur]);
		 ++Cur;
	}
	std::swap(array[++Prev], array[right]);
	return Prev;
}

void QuickSort(int array[], int left, int right)
{
	if(left < right)
	{
	   int div = partion4(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

void QuickSort_nor(int *array, int size)
{
	stack<int> s;
	s.push(size-1);
	s.push(0);
	while(!s.empty())
	{
		int left = s.top();
		s.pop();
		int right = s.top();
		s.pop();

		if(left < right)
		{
			int div = partion3(array, left, right);
			s.push(right);
			s.push(div +1);
			s.push(div -1);
			s.push(left);
		}

	}
}
*/ 


YOLOv11改进 | 主干/Backbone篇 | 轻量级移动端网络ShuffleNetV2(附代码+修改教程) 本文给大家带来的改进内容是ShuffleNetV2,这是一种为移动设备设计的高效CNN架构。其在ShuffleNetV1的基础上强调除了FLOPs之外,还应考虑速度、内存访问成本和平台特性。(我在YOLOv11n上修改该主干降低了GFLOPs,但是参数量还是有一定上涨,其非常适合轻量化的读者来使用,同时精度也有一定程度的上涨)。本文通过介绍其主要框架原理,然后教你如何添加该网络结构到网络模型中。 阅读详情

相关推荐

别再只盯着时序了!聊聊SDC里那些容易被忽略的‘配角’命令:工作条件、线载模型与面积约束

本文深入探讨了SDC(设计约束)中常被忽视的关键命令,包括set_operating_conditions、set_wire_load_model和set_max_area。这些‘配角’命令在芯片设计中扮演着至关重要的角色,影响时序收敛、功耗和面积优化。文章通过实际案例和最佳实践,揭示了如何正确配置工作条件、选择线载模型以及动态调整面积约束,以提升设计质量和效率。

weixin_26875109的博客 208

F#的快速排序算法

基本思路 将list分成做扫描以及右扫码两个部分,即leftList以及rightList,先对数组从左往右扫描,找到第一不大于当前定义的关键值数,与它进行交换。然后再从右往左进行扫描,找到第一个不小于当前关键值的数,将它们交换,然后将数据分成两个部分,前面一部分都小于关键字,后面一部分都大于关键字,然后再前后的部分继续进行前面描述的操作(递归的调用自己)。 代码 let rec quickSort (list : int list) = match list with | []

weixin_45839504的博客 477

别再傻傻分不清了!用Design Compiler和PrimeTime实操对比PBA与GBA模式

本文深度解析静态时序分析(STA)中Design Compiler与PrimeTime工具的PBA与GBA模式差异,通过实际案例演示两种模式在转换时间计算、时钟路径分析等方面的对比,并提供工程实践中模式选择的策略与调试技巧,帮助工程师在芯片设计流程中平衡精度与效率。

weixin_42552315的博客 415

算法 quick sort

// --------------------------------------------------------------------------------------------------------------------   //  //   // Respect the work.   //   //    //    //   // The quick sor

玮哥的博客 792

a股level2数据接口的最优委托信息

Level-1提供的数据并不可以知道委托了xxx手是有多少人下的,以及每个人下了多少的明细。通过Level-2的这个详细买卖盘数据,盘口上的单子到底是散户小打小闹,还是主力真刀实枪在干,都一览无余。交易类型:1-市价,2-限价,3-本方优先,10-撤单, 11-暂不清楚( 基金/ 债券有此值)除了提供逐笔成交记录这个信息外,还提供了最优委托信息,也就是盘口中前50笔订单的委托数量明细。那么Level-2盘口委托数据的速度更新是非常快的,大家可以通过。交易方向:0-未知,1-买入,2-卖出。

Qq_2037696191的博客 1169

python-调用动态链接库dll/so的方法

使用python ctyeps CDLL来调用linux下的so动态链接库或windows下的dll动态链接库

XIAOXIANG233233的博客 3663

F#的快排

F# 的快排实现起来很简单,因为集合类List里面的方法帮用户实现了大部分的代码。 下面就是就是代码: let rec quickSort (list : int list) = match list with | [] -> [] | [single] -> [single] | head :: tail -> ...

weixin_30598225的博客 195

反激系列-详细到每个容阻的原理之RCD吸收(1)

1、漏感尖峰电压会被RCD吸收,漏感能量一定,电容越大,电容充电的电压就越低,吸收能力就越强,MOS漏极的电压就越低。2、在漏感能力释放完之后(这个过程一般只有一个周期的3%时间),是要通过R1释放掉电容吸收的能量的,把电容的电压降下来方便下一次漏感尖峰来之前再进行吸收。3、电容容量和电阻需要合理搭配,容量足够即可,足够能吸收漏感尖峰电压,不至于超过MOS耐压。电阻需要足够小,小到在放电阶段把电容电压下降到MOS的电压平台。

Cuxiaoweiba的博客 3万+

数据结构-交换排序(冒泡算法,快速排序)

1,冒泡排序思想 冒泡算法是一种基于交换思想的排序算法,算法每次都和相邻的两个元素比较,把比较结果比较大的哪一个元素逐渐的交换到最后的位置,经过n-1趟比较后,整个序列有序。可以看到,冒泡算法的每一趟排序都有一个元素被放到最终的位置,下面我们通过一个例子看看冒泡排序的过程。 2,冒泡排序过程分析 首先看我们的原始数据,每次都把前面的一个元素和后面的一个元素比较,如果前面元素小于后面元素,不发生交换,如果前面元素大于后面元素,就发生交换,直到遍历完所有的元素,此时我们的第一趟排序完成,从结果来看,我

理科男同学 1149

2023华为od机试C卷【最富裕的小家庭】C语言 实现

在一颗树中,每个节点代表一个家庭成员,节点的数字表示其个人的财富值,一个节点及其直接相连的子节点被定义为个小家庭。现给你一颗树,请计算出最富裕的小家庭的财富和。

MISAYAONE的博客 502

AutoSAR系列讲解(深入篇)14.7-Mcal Adc配置(上)

详细讲解了ADC的各个配置项的作用

雪云飞星的博客 1万+

【排序三】交换排序(冒泡排序&&快速排序)

【排序一】插入排序(直接插入排序&&希尔排序) 【排序二】选择排序(选择排序&&堆排序) 一、冒泡排序 1、基本思想     冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排序)是一种简单的排序算法。为什么会叫做冒泡排序呢?这是由于它的算法思想就类似于鱼儿在河里吐泡泡的场景,例如升序排列一列数,它会两两相邻的数据进行比较,如果前者大于后者就交换,重复此番工作直到交换到最后两

snow_5288的博客 1万+

新手必看!一步步教您如何获取可用的D音Cookie(为什么我复制的D音Cookie无法正常使用?)

新手必看!一步步教您如何获取可用的抖音Cookie(为什么我复制的抖音Cookie无法正常使用,无法下载无水印视频?)

XiaoqiangClub的博客 1495

【数据结构】——交换排序算法:冒泡排序、快速排序

一、冒泡排序:(稳定) 1.基本思想   成对比较: 比较相邻元素,若第一个大于第二个,则交换 对每一对相邻元素做同样工作,这一步完成后最后的元素将是最大的数 针对所有元素重复以上过程(除去排好序的数字) 没有任何一对元素发生交换时,停止排序 2.代码实现 #冒泡排序 m=[1,3,4,2] def Bubble_sort(alist): n=len(alist) count=False for i in range(0,n-1):#循环每一对 for j in

m0_46568930的博客 197

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

数据结构——排序算法第二幕(交换排序:冒泡排序、快速排序(三种版本) 归并排序:归并排序(分治))超详细!!!!

快速排序的三种方法以及归并排序 超详细!!!

daily_233的博客 6177

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

数据结构:常见排序算法(3) -- 交换排序(冒泡排序、快速排序)

(1)冒泡排序 ①原理: 在无序区间,通过相邻数的比较,将最大的数冒泡到无序区间的最后,持续这个过程,直到数组整体有序 ②代码实现: import java.util.Arrays; //冒泡排序: 时间复杂度O(n^2) 空间复杂度:O(1) public class bubbleSort { public static void main(String[] args) { int[] array={5,8,1,2,5,22,44,15,3,0,48}; S

Java学习小书屋 1414

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

【数据结构与算法】(13):交换排序算法:冒泡排序、快速排序的3种递归实现,非递归实现和三路归并实现

详细解读冒泡排序;快速排序的递归方法中的三种分区方式,Hoare分区,Lomuto分区和前后指针法分区;非递归实现快速排序、三路归并实现快速排序。

更新C/C++,数据结构与算法,计算机视觉,深度学习,目标检测 1319

图解"数据结构--内部排序算法"----交换排序:冒泡排序、快速排序

一、交换排序的基本思想 两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。 二、交换排序分类     本文介绍两种交换排序方法:冒泡排序、快速排序 2.1 冒泡排序        2.1.1 冒泡排序基本思想     每次遍历完序列都把最大(小)的元素放在最前面,然后再对剩下的序列重复前面的一个过程,每次遍历完之后待

马兆娟 廊坊师范学院信息技术提高班第八期 5655

【数据结构】常见的排序算法 -- 交换排序

本文介绍了两种交换排序算法:冒泡排序和快速排序。冒泡排序通过相邻元素比较交换,逐步将最大值"冒泡"到数组末尾,时间复杂度为O(N^2)。快速排序采用分治思想,选取基准值将数组分为两部分递归排序,包括hoare、挖坑法和前后指针三种实现方式,平均时间复杂度为O(n*logn)。文章还提供了快速排序的非递归实现方案,采用栈结构模拟递归过程,保持了算法的高效性但避免了递归带来的额外开销。两种算法平均时间复杂度差异明显,快速排序在实际应用中更高效。

小年糕的博客 1153

C++排序算法(上)冒泡排序、计数排序、选择排序、快速排序、堆排序

前言冒泡排序法。

u014136435的博客 377

常用排序方法图解(冒泡,快速排序,堆排序)

详解三种典型的算法排序冒泡,快速排序,堆排序。对每种排序都有原理,步骤,图解,代码。

liaoyaonline的博客 379

回顾一下冒泡排序和快速排序

然后寻找比pivot更小的数放在其左边,这时我们用i去定义为小于等于pivot的右边界,j从基准的下一个位置开始一直更新到right右边界。比如目前数组为3,1,2,4,5,那么j从1开始向后遍历,最终返回的索引i是2,这一次交换完位置的数组为21345。

weixin_45927386的博客 398

C语言(排序算法1)(冒泡排序与快速排序)

第二轮排序时,可以忽略最右边的位置开始排序(因为最右边是max,不会有其他数比它更大),在余下的数中还会有一个值是除了max以外最大的值,我们将其称为max-mini。冒牌排序的原理就是让每个相邻的元素比较大小,如果不满足次序,就要将两者的顺序调换过来。再使用递归使得所有的元素左边都是小于等于本身,右边的元素大于等于本身。3)每一轮冒泡排序结束后,就会有一个当前的最大值(或最小值)被送到最右边,下次排序时将这个元素忽略。1)找到“标准元素i”,使得i左边的所有元素都小于i,i右边的所有元素都大于i。

tomatop的博客 227

数据结构相关排序

                              数据结构排序梳理(面试后的决心)        从前向后(或从后向前)依次比较相邻的元素,若发现逆顺序,则交换。小的向前换,大的向后换,像水底的气泡逐渐向上冒,顾名思义冒泡排序法。 通俗一点就是把大的往上挪!向冒泡一样。 缺点:冒泡排序法效率较低。   冒泡排序       从前向后(或从后向前)依次比较相邻的元素,若发现逆顺序,...

无良的奋斗首年的博客 312

冒泡排序,选择排序,插入排序,快速排序

文章目录一、冒泡排序二、选择排序三、插入排序四、快速排序 一、冒泡排序 public static void 冒泡(int[] nums){//倒序 boolean b = true; for (int i = 0,n = nums.length; i < n && b; i++) { b = false; for (int j = 0; j < n - i - 1; j++) { if (nums[j] &

还是要稳扎稳打 343

[我的第一本算法书] 第二章 排序算法 摘录(冒泡排序,选择排序,插入排序,堆排序,归并排序,快速排序)

冒泡排序:就是重复’从序列右边开始比较相邻两个数字的大小,再根据结果交换两个数字的位置’这一操作的算法.这一过程中,数字像泡泡一样,慢慢从右向左’浮’到序列的顶端,所以这个算法才被成为’冒泡排序’ 在冒泡排序中,第一轮要比较n-1次,第二轮要比较n-2次…第n-1轮要比较1次,最终时间复杂度O(n^2),和输入数据的排列顺序无关 选择排序:就是重复’从待排序的数据中寻找最小值,将其与序列最左边的...

www.iqer.info 249
上一篇: 面试题:找出公司员工最喜欢的k种水果
下一篇: 八大排序算法:插入(2:插入、希尔)、选择(2:选择、堆)、交换(2:冒泡、快速)、归并、基数
Sharp_UP
博客等级 码龄10年 86粉丝 78原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值