冒泡快速等算法总结

最新推荐文章于 2021-09-30 08:27:42 发布
最新推荐文章于 2021-09-30 08:27:42 发布
阅读量515 收藏
点赞数
分类专栏： 算法 文章标签： 冒泡排序 希尔排序 快速排序 归并排序 插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010439954/article/details/43819965
版权

冒泡排序：从前（后）第一个数起与其后的第二个进行比较交换，以此往后，到第二个数与其后的第二个进行比较交换。最后一个数变为极大（小）值，以此从最后排序，形成冒泡。

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

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

void BubbleSort(int array[], int length)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < length; i++)
	{
		for(j = length-1; j > i; j--)
		{
			if( array[j] < array[j-1] )
			{
				swap(array, j, j-1);			
			}
		show(array, length);
		}
	}

}

int main()
{
	int array[] ={8,3,6,1};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	BubbleSort(array, length);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}



对冒泡排序的进一步的加强，加一个标志位，当某一趟冒泡排序没有元素交换时，则冒泡结束，元素已经有序，可以有效的减少冒泡次数。

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

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

void BubbleSort(int array[], int length)
{
	int i = 0;
	int j = 0;
	bool if_finish = true;
	for(i=0; (i<length) && if_finish; i++)
	{
		if_finish = false;
		for(j=length-1; j>i; j--)
		{
			if( array[j] < array[j-1] )
			{
				swap(array, j, j-1);
				if_finish = 1;
			}
		}
	}
}

int main()
{
	int array[] ={8,3,6,1};
	int length = sizeof(array) / sizeof(*array); 
	show(array, length);
	BubbleSort(array, length);
	show(array, length);
	return 0;
}

选择排序法：从第一个数起，选其后的最小的数与之交换，以此往后。 

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

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

void SelectionSort(int array[], int length) 
{
	int i = 0;
	int j = 0;
	int sign = -1;

	for(i=0; i<length; i++)
	{
		sign = i; 
		for(j = i+1; j<length; j++)
		{
			if( array[j] < array[sign] ) 
			{
				sign = j;	
			}
			
		}
		if(i != sign)
		{
			show(array, length);
			swap(array, i, sign);
			show(array, length);
			cout<<endl;
		}
	}
}
int main()
{
	int array[] ={4, 1, 3, 2};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	SelectionSort(array, length);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}



插入排序：从第一个数X起，与其之后遇到的第一个比其大（小）的数Y，并将Y前面个个数都后移一位，并将Y移至X，之后到第二个数，以此往后。。。。

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

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

void InertionSort(int array[], int length) 
{
	int i = 0;
	int j = 0;
	int sign = -1;
	int temp = -1;
	for(i=1; i<length; i++)
	{
		sign = i; 
		temp = array[sign];

		for(j = i-1; (j>=0) && (array[j]>temp); j--)
		{ 
			array[j+1] = array[j]; 
			sign = j; 
		}
		array[sign] = temp;
		show(array, length);
	}
}
int main()
{
	int array[] ={3, 1, 6, 5, 4, 2};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	InertionSort(array, length);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}



希尔排序：举例以效率比较高的3为例，n=length,n=n/3+1，第一个数与其后以3为倍数的个个数比较并排序，第二个数与其后以3为倍数的个个数比较并排序，以此为类...

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

void swap(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}
void ShellSort(int array[], int length)
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;
	int gap = length ;
	while( gap > 1)
	{
		gap = gap / 3 + 1;
		cout<<gap;
		for(i=gap; i<length; i+=gap)
		{
			k = i;
			temp = array[k];
			for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)
			{
				array[j+gap] = array[j];
				k = j;
			}
			array[k] = temp;
		}
		show(array, length);

		
	}

}

int main()
{
	int array[] ={7, 1, 6, 5, 4, 2};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	ShellSort(array, length);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}

快速排序： 

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}

void swap(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}
int partition(int array[], int low, int high)
{
	int pv = array[low];

	while( low < high )
	{
		while( (low < high) && (array[high] >= pv) )
		{
			high--; 
		}
		swap(array, low, high);
		while( (low < high) && (array[low] <= pv) )
		{
			low++;
		}
		swap(array, low, high);
	}
	return low;
}

void QSort(int array[], int low, int high)
{
	if( low < high )
	{
	
		int pivot = partition(array, low, high);
		QSort(array, low, pivot-1);
		QSort(array, pivot+1, high);
	}
}

int main()
{
	int array[] ={4, 1, 6, 5, 7, 2};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	QSort(array,0,length-1);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}
归并排序 

#include <iostream>
using namespace std;
void show(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
}
void Merge(int src[], int des[], int low, int mid, int high)
{
	int i = low;
	int j = mid + 1;
	int k = low;

	while( (i <= mid) && (j <= high) ) 
	{
		if( src[i] < src[j] )
		{
			des[k++] = src[i++];
		}
		else
		{
			des[k++] = src[j++];
		}
	}

	while( i <= mid )  
	{
		des[k++] = src[i++];
	}
	while( j <= high ) 
	{
		des[k++] = src[j++];
	}
}

void MSort(int src[], int des[], int low, int high, int max)
{
	if( low == high ) 
	{
		des[low] = src[low]; 
	}
	else 
	{
		int mid = (low + high) / 2;
		int* space = (int*)malloc(sizeof(int) * max);
		if( space != NULL )
		{
			MSort(src, space, low, mid, max); 
			MSort(src, space, mid+1, high, max);
			Merge(space, des, low, mid, high); 
		}
		free(space);
	}
}

int main()
{
	int array[] ={4, 1, 6, 5, 7, 2};
	int length = sizeof(array) / sizeof(*array); 
	cout<<"排序前"<<endl;
	show(array, length);
	cout<<endl;
	MSort(array, array, 0, length-1, length);
	cout<<endl;
	cout<<"排序后"<<endl;
	show(array, length);
	return 0;
}



半片瓜
关注
专栏目录
快速、冒泡排序算法比较
06-16
试通过随机数据比较快速排序、起泡排序各算法的关键字比较次数和关键字移动次数。 （1）待排序表的表长不小于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。 （2）最后要对结果作出简单分析，包括对各组数据得出结果波动大小的解释。 （3）对冒泡排序应指出进行了多少趟。
Java排序算法总结之冒泡排序
09-03
相比于冒泡排序，快速排序、堆排序以及归并排序等算法在平均和最坏情况下的时间复杂度都更低，为O(nlogn)。其中，快速排序和堆排序虽然不具备稳定性，但在大多数情况下性能更优。而稳定的排序算法如归并排序和冒泡...
冒泡等一系列的算法
夏希月
12-25 312
字符与字节; 1个字节等于8个bit位，每个bit位又0/1两种状态也就是说一个字节可以表示256个状态，计算机里用字节来作为最基本的存储单位。一般来说，英文状态下一个字母或数字（称之为字符）占用一个字节，一个汉字用两个字节表示。在不同的编码方式下一个字符占的字节书不太一样。  package com.sort; import java.util.Date; public class Sort {...
效率最高的冒泡与快排算法 C语言实现
qq_39903347的博客
10-07 409
效率最高的冒泡与快排算法 C语言实现冒泡排序思想代码快速排序思想代码 冒泡排序 思想 不断地把最大或最小元素不断冒出来。 如排序5 3 4 9 7 6 2 假如我们用升序的方式，从左边开始扫描，相邻元素两两比较，当左边元素比右边大时就交换，反之，则不用交换。 第一趟循环后的结果为：3 1 5 4 6 7 4 9 这样就把最大的9冒出来了 第二塘循环后的结果为：1 3 4 5 6 4 7 9 这样就把最大的7冒出来了 以此循环，结果如下代码图所示 代码 #include<stdio.h> v
冒泡排序和快速排序算法
shine的博客
05-13 7730
序言： 一 冒泡排序算法 二 冒泡排序程序实现 三 快速排序算法 四 快速排序算法程序实现 第一冒泡排序算法 简介 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列...
js排序算法：插入、冒泡、快速（整理3种）
cy29403的博客
08-28 185
整理常见3中排序方法：插入排序、冒泡排序、快速排序。 原文链接：https://juejin.im/entry/5979bed7f265da3e13573e8c?utm_medium=hao.caibaojian.com&utm_source=hao.caibaojian.com 手动排序：冒泡排序 通用公式如下: x+=y; y=x-y; x-=y; 实例如下： /...
Java-快速排序、冒泡排序和堆排序三种排序讲解、对比及总结.md
最新发布
07-05
Java-快速排序、冒泡排序和堆排序三种排序讲解、对比及总结 Java-快速排序、冒泡排序和堆排序三种排序讲解、对比及总结 Java-快速排序、冒泡排序和堆排序三种排序讲解、对比及总结
C语言的冒泡排序和快速排序算法使用实例
09-03
总结来说，冒泡排序和快速排序都是常见的排序算法，但快速排序通常在效率上优于冒泡排序。冒泡排序简单直观，适用于小规模数据或已接近有序的数据；而快速排序在处理大规模数据时表现出色，是实践中常用的排序算法之...
基于matlab实现的快速排序算法以及冒泡排序算法，可以直接调用.rar
05-02
快速排序和冒泡排序是两种常见的排序算法，它们在计算机科学和编程中有着广泛的应用。在MATLAB这种高级数学计算环境中，实现这两种排序算法能够帮助我们更好地理解和优化数据处理过程。 快速排序是一种高效的排序...
冒泡与快速排序比较
12-17
对于冒泡排序和快速排序的比较次数与移动次数进行比较
三种基础排序(快速，冒泡，插入)
来年三月
02-19 253
快速，冒泡，插入 数组排序需要注意： 数组下标的位置是否越界 数组下标所对应比较的值在循环中是否发生改变（对应下标的值改变，或者变量自增导致变量数值发生改变比如i++） // 快速排序法 一个数字跟其他所有数字进行比较 将最大的数字换到最后 private void quickSort(int[] nums) { //数组长度 int len = nums.length;...
常用排序（冒泡、快速、选择）
kiddingboy_wjj的博客
03-05 634
常见排序算法的使用1、冒泡排序 冒泡排序思想是从头开始扫描待排序的元素，在这过程中相邻两个元素之间进行比较，将较大的数向后移，（即大数向下沉，小数向上冒），经过从头到尾的一次扫描后，当前最大的数就会被移动到最后一位了，然后记下这个位置，下一次扫描只需扫描到这个位置即可（即第i此扫描需要比较n-i次）。第i次扫描会将一个第i大的数排到倒数第i位上。 代码实现：public void MPsort(){
冒泡、二分、快速
拼搏的少年的博客
10-27 398
1、冒泡算法的原理:冒泡排序算法的一般性策略：搜索整个值列，比较相邻元素，如果两者的相对次序不对，则交换它们，其结果是最大值“想水泡一样”移动到值列的最后一个位置上，这也是它在最终完成排序的值列中合适的位置。然后再次搜索值列，将第二大的值移动至倒数第二个位置上，重复该过程，直至将所有元素移动到正确的位置上。 下面是两个Java冒泡算法程序 2、冒泡代码如下：public class Bubbl
快速/冒泡排序算法
qq_37287621的博客
10-12 258
排序算法简单介绍： 1.冒泡排序 思路：1）先用第一个与后面的元素依次比较，如果第一个大于某个元素，就交换他们的值； 2）然后再用第二个与后面的元素依次比较，如果它大于，就交换值； 3）重复操作，直到最后一个值结束，得到的新数组就是有序的了 import random # data=[random.randint(0,100) for i in range(10)] # print(&quot;待排序的随机...
快速排序/冒泡/选择
geter_CS的博客
04-02 271
快排C++ #include <iostream> int subSort(int num[],int l,int r){ int X=num[l]; int i=l; int j=r; while(i<j){ while(num[j]>=X&&i<j) j--; if (num[j]&...
JAVA 排序算法(快速、冒泡)
进击的程序猿
06-01 102
    快速排序： public static void quiteSort(int[] o, int low, int hight) { if (low &lt; hight) { int povitePosition = adjust(o, low, hight); quiteSort(o, low, povitePosition - 1); quiteSort(o...
【算法】——冒泡排序与快速排序的分析
sjp11的博客
09-30 1004
冒泡排序 冒泡排序的基本思想时： 冒泡排序的步骤很简单，只需要将较大的值往后挪，直到将最大的值移动到最后面的时候，就完成一趟排序，重复以上步骤，将第二大的值，第三大的值......移动到最后面，直到排序完成. 如下图所示： 代码： void swap(int* left, int* right) { int tmp = *left; *left = *right; *right = tmp; } void BubbleSort(int arr[], int n) { for.
冒泡排序和快速排序
Xym's Blog
03-19 265
文章目录数据结构交换排序的实现1. 冒泡排序2. 快速排序 数据结构交换排序的实现 1. 冒泡排序         冒泡排序是一种稳定的排序算法，基本思想：从后往前或从前往后两两比较相邻的关键字，若不是我们想要的那个顺序，则交换他们的位置，并不断向前进行比较大小，直到最小或最大的关键字在待排序列的第一个位置，这样一趟排...
算法总结：冒泡、选择与快速排序解析
"这是关于基本算法的个人总结，涵盖了排序算法、树、链表以及八皇后问题等核心概念。" 在算法领域，排序算法是基础且重要的部分，它们用于组织和整理数据，提升数据处理效率。这里我们将深入探讨两种常见的排序算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值