排序：快速排序与选择排序

最新推荐文章于 2023-01-26 20:49:10 发布
最新推荐文章于 2023-01-26 20:49:10 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： 数据结构 排序 C语言 文章标签： C语言 快速排序 冒泡排序 选择排序 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qaz3171210/article/details/46527083
版权
C语言 同时被 3 个专栏收录
256 篇文章 6 订阅
订阅专栏
数据结构
31 篇文章 1 订阅
订阅专栏
排序
4 篇文章 0 订阅
订阅专栏

      在最近的学习中，对于排序算法进行了一定的学习，在这里对快速排序和选择排序的部分内容进行说明，其余内容在后期会进行补充，感谢大家提出宝贵意见。


宏定义如下：

<span style="font-size:18px;"><strong><strong><span style="font-size:18px;">#include <iostream>
using namespace std;

#define M 21

typedef int SqList[M];</span></strong></strong></span>

一.冒泡排序 

<span style="font-size:18px;"><strong><strong><span style="font-size:18px;">void BubbleSort(SqList &L,int n)                  //冒泡排序
{
	for(int i = 0;i < n-1;++i)                      //外层循环记录循环次数
	{
		for(int j = 0;j < n-i-1;++j)              //内层循环记录每一次循环比较的次数
		{                                         //（j<n-i-1）比较一次后，其后值不参与再比较
			if(L[j] > L[j+1])                     //若前者大于后者，则交换位置
			{
				int tmp = L[j];
				L[j] = L[j+1];
				L[j+1] = tmp;
			}
		}
	}
}</span></strong></strong></span>

二.快速排序 

<span style="font-size:18px;"><strong><strong><span style="font-size:18px;">//改进方式，直接赋值
int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
	int key = L[low];                             //枢轴记录关键字
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			high--;                               //向前比较
		}
		L[low] = L[high];                         //否则赋值
		while(low < high && L[low] <= key)        //若左边的小于枢轴
		{
			low++;                                //向后比较
		}
		L[high] = L[low];                         //否则赋值
	}
	L[low] = key;                                 //此时low = high，即可等价为L[high] = key,枢轴记录到位
	return low;                                   //返回此时位置
}

//交换方式
/*int Partition(SqList &L,int low,int high)
{
	int key = L[low];
	while(low < high)
	{
		while(low < high && L[high] >= key )
		{
			high--;
		}
		int tmp = L[low];
		L[low] = L[high];
		L[high] = tmp;
		while(low < high && L[low] <= key)
		{
			low++;
		}
		tmp = L[low];
		L[low] = L[high];
		L[high] = tmp;
	}
	return low;
}*/

void QuickSort(SqList &L,int low,int high)        //快速排序
{
	if(low < high)
	{
		int prvitloc = Partition(L,low,high);     //将数组一分为二
		QuickSort(L,low,prvitloc-1);              //左半部分排序
		QuickSort(L,prvitloc+1,high);             //右半部分排序
	}
}</span></strong></strong></span>

对于快速排序有如下的优化方法：

1.L[low] L[high] L[(low+high)/2]从中找中间值作为枢值

实现代码如下：

//改进方法 L[low] L[high] L[(low+high)/2]从中找中间值作为枢值
int Index(int a,int b,int c)                                //查找作为枢值的值
{
	if(a < b)
	{
		if(a < c)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
	else //b <= a
	{
		if(c < a)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
}

int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
	int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			high--;                               //向前比较
		}
		int tmp = L[low];                         //交换位置
		L[low] = L[high];
		L[high] = tmp;                         
		while(low < high && L[low] < key)         //若左边的小于枢轴
		{
			low++;                                //向后比较
		}
		tmp = L[low];                             //交换位置
		L[low] = L[high];
		L[high] = tmp;                       
	} 
	return low;                                   //返回此时位置
}

测试代码与原方法相同。

2.改进方法 L[low] L[high] L[(low+high)/2]从中找中间值作为枢值且在指针high增1和low减1时同时进行冒泡操作，即在相邻两个纪录处于“逆序”时进行交换，同时算法中附设两个布尔型变量分别指示low和high在从两端向中间移动过程中是否进行交换记录的操作，若指针low在从低端向中间的移动过程中没有进行交换记录的操作，则不再需要对低端子表进行操作，同理高端子表类似。

实现代码如下：

//改进方法 L[low] L[high] L[(low+high)/2]从中找中间值作为枢值且在指针high增1和low减1时同时进行冒泡操作
//即在相邻两个纪录处于“逆序”时进行交换，同时算法中附设两个布尔型变量分别指示low和high在从两端向中间
//移动过程中是否进行交换记录的操作，若指针low在从低端向中间的移动过程中没有进行交换记录的操作，则不再
//需要对低端子表进行操作，同理高端子表类似

int Index(int a,int b,int c)                                //查找作为枢值的值
{
	if(a < b)
	{
		if(a < c)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
	else //b <= a
	{
		if(c < a)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
}

bool Right(SqList &L,int low,int high)             //布尔型变量指示low从左向中间移动过程中是否进行交换记录的操作
{
    int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high && L[high] >= key )      //若右边的大于枢轴
	{
		int tmp = high;
		high--;                               //向前比较
		if(L[tmp] < L[high])
		{
			return true;                     //判断真值
		}
	}                     
	while(low < high && L[low] < key)         //若左边的小于枢轴
	{
		int tmp = low;
		low++;                                //向后比较
	}                       
}

bool Left(SqList &L,int low,int high)             //布尔型变量指示high从右向中间移动过程中是否进行交换记录的操作
{
	int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high && L[high] >= key )      //若右边的大于枢轴
	{
		int tmp = high;
		high--;                               //向前比较
	}                        
	while(low < high && L[low] < key)         //若左边的小于枢轴
	{
		int tmp = low;
		low++;                                //向后比较
		if(L[tmp] > L[low])
		{
			return true;
		}
	}                   
}

int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
    int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			int tmp = high;
			high--;                               //向前比较
			if(L[tmp] < L[high])                  //相邻两位比较大小
			{
				int exp = L[tmp];
				L[tmp] = L[high];
				L[high] = exp;
			}
		}                        
		while(low < high && L[low] < key)         //若左边的小于枢轴
		{
			int tmp = low;
			low++;                                //向后比较
			if(L[tmp] > L[low])                   //相邻两位比较大小
			{
				int exp = L[tmp];
				L[tmp] = L[low];
				L[low] = exp;
			}
		}                     
	} 
	return low;                                   //返回此时位置
}

测试代码有了一定改变，如下所示： 

void QuickSort(SqList &L,int low,int high)        //快速排序
{
	bool left = Left(L,low,high);
	bool right = Right(L,low,high) ;
	if(low < high)
	{
		int prvitloc = Partition(L,low,high);         //将数组一分为二
		if(!left)                                     //若左半部分没有进行数值交换
		{
			QuickSort(L,low,prvitloc-1);              //左半部分排序
		}
		if(!right)                                    //若右半部分没有进行数值交换
		{
			QuickSort(L,prvitloc+1,high);             //右半部分排序
		}
	}
}

三.简单选择排序

<span style="font-size:18px;"><strong><strong><span style="font-size:18px;">int SelectMinKey(SqList &L,int n,int key)         //选择第key小的记录下标     
{
	for(int k = key+1;k < n;++k)                  //只比较key之后的
	{
		if(L[k] < L[key])                         //若小于则记录下标
		{
			key = k;
		}
	}
	return key;                                   //返回下标
}

void SelectSort(SqList &L,int n)                  //简单选择排序
{
	for(int i = 0;i < n-1;++i)
	{
		int j = SelectMinKey(L,n,i);              //第key小的记录位置
		if(i != j)                                //若不为此位置数，则交换位置
		{
			int tmp = L[i];
			L[i] = L[j];
			L[j] = tmp;
		}
	}
}</span></strong></strong></span>

四.堆排序

void Heapify(SqList &L,int low,int high)
{
	int sq = L[low];                         //将根结点保存在sq中
	for(int j = 2*low;j <= high;j *= 2)      
	{
		if(j < high && L[j] < L[j+1])        //沿关键字较大的孩子结点向下筛选
		{
			j++;                             //关键字较大节点下标
		}
		if(sq > L[j])                        //若孩子结点的值小于根结点的值，则不进行交换
		{
			break;
		}
		L[low] = L[j];
		low = j;
	}
	L[low] = sq;                             //将根结点插入到正确位置
}


void BuildHeap(SqList &L,int n)         //建立大顶堆
{
	for(int i = n/2;i > 0;i--)          //从序号n/2开始建立大顶堆
	{
		Heapify(L,i,n);
	}
}


void HeapSort(SqList &L,int n)
{                                       //对L[1..n]进行堆排序，不妨用L[0]做暂存单元
	BuildHeap(L,n);                     //将L[1-n]建成初始堆
	for(int i = n-1;i > 1;i--){ 
		                                //对当前无序区L[1..i]进行堆排序，共做n-1趟。
		L[0]=L[1];
		L[1]=L[i];
		L[i]=L[0];
		                                //将堆顶和堆中最后一个记录交换
		Heapify(L,1,i-1);
		                                //将L[1..i-1]重新调整为堆，仅有L[1]可能违反堆性质
	} 
}

测试代码如下： 

void main()
{
	SqList sq = {0,53,24,35,56,32,78,99}; 
	HeapSort(sq,8);
	for(i = 1;i < 8; ++i)
	{
		cout<<sq[i]<<" ";
	}
	cout<<endl;
}


具体代码如上，如有任何问题请大家指出，谢谢。


如下附上完整版函数和测试代码：

#include <iostream>
using namespace std;

#define M 21

typedef int SqList[M];

void BubbleSort(SqList &L,int n)                  //冒泡排序
{
	for(int i = 0;i < n-1;++i)                    //外层循环记录循环次数
	{
		for(int j = 0;j < n-i-1;++j)              //内层循环记录每一次循环比较的次数
		{                                         //（j<n-i-1）比较一次后，其后值不参与再比较
			if(L[j] > L[j+1])                     //若前者大于后者，则交换位置
			{
				int tmp = L[j];
				L[j] = L[j+1];
				L[j+1] = tmp;
			}
		}
	}
}


//改进方法 L[low] L[high] L[(low+high)/2]从中找中间值作为枢值
int Index(int a,int b,int c)                                //查找作为枢值的值
{
	if(a < b)
	{
		if(a < c)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
	else //b <= a
	{
		if(c < a)
		{
			if(b < c)
			{
				return b;
			}
			else
			{
				return c;
			}
		}
		else
		{
			return a;
		}
	}
}

/*int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
	int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			high--;                               //向前比较
		}
		int tmp = L[low];                         //交换位置
		L[low] = L[high];
		L[high] = tmp;                         
		while(low < high && L[low] < key)         //若左边的小于枢轴
		{
			low++;                                //向后比较
		}
		tmp = L[low];                             //交换位置
		L[low] = L[high];
		L[high] = tmp;                       
	} 
	return low;                                   //返回此时位置
}*/


//改进方法 L[low] L[high] L[(low+high)/2]从中找中间值作为枢值且在指针high增1和low减1时同时进行冒泡操作
//即在相邻两个纪录处于“逆序”时进行交换，同时算法中附设两个布尔型变量分别指示low和high在从两端向中间
//移动过程中是否进行交换记录的操作，若指针low在从低端向中间的移动过程中没有进行交换记录的操作，则不再
//需要对低端子表进行操作，同理高端子表类似


bool Right(SqList &L,int low,int high)             //布尔型变量指示low从左向中间移动过程中是否进行交换记录的操作
{
    int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high && L[high] >= key )      //若右边的大于枢轴
	{
		int tmp = high;
		high--;                               //向前比较
		if(L[tmp] < L[high])
		{
			return true;                     //判断真值
		}
	}                     
	while(low < high && L[low] < key)         //若左边的小于枢轴
	{
		int tmp = low;
		low++;                                //向后比较
	}                       
}

bool Left(SqList &L,int low,int high)             //布尔型变量指示high从右向中间移动过程中是否进行交换记录的操作
{
	int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high && L[high] >= key )      //若右边的大于枢轴
	{
		int tmp = high;
		high--;                               //向前比较
	}                        
	while(low < high && L[low] < key)         //若左边的小于枢轴
	{
		int tmp = low;
		low++;                                //向后比较
		if(L[tmp] > L[low])
		{
			return true;
		}
	}                   
}

int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
    int key = Index(L[low],L[high],L[(low+high)/2]);
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			int tmp = high;
			high--;                               //向前比较
			if(L[tmp] < L[high])                  //相邻两位比较大小
			{
				int exp = L[tmp];
				L[tmp] = L[high];
				L[high] = exp;
			}
		}                        
		while(low < high && L[low] < key)         //若左边的小于枢轴
		{
			int tmp = low;
			low++;                                //向后比较
			if(L[tmp] > L[low])                   //相邻两位比较大小
			{
				int exp = L[tmp];
				L[tmp] = L[low];
				L[low] = exp;
			}
		}                     
	} 
	return low;                                   //返回此时位置
}
//改进方式，直接赋值
/*int Partition(SqList &L,int low,int high)         //返回枢轴所在位置，它之前的小于它
{                                                 //之后的大于它
	int key = L[low];                             //枢轴记录关键字
	while(low < high)                             //判别条件，不满足时结束
	{
		while(low < high && L[high] >= key )      //若右边的大于枢轴
		{
			high--;                               //向前比较
		}
		L[low] = L[high];                         //否则赋值
		while(low < high && L[low] <= key)        //若左边的小于枢轴
		{
			low++;                                //向后比较
		}
		L[high] = L[low];                         //否则赋值
	}
	L[low] = key;                                 //此时low = high，即可等价为L[high] = key,枢轴记录到位
	return low;                                   //返回此时位置
}*/

//交换方式
/*int Partition(SqList &L,int low,int high)
{
	int key = L[low];
	while(low < high)
	{
		while(low < high && L[high] >= key )
		{
			high--;
		}
		int tmp = L[low];
		L[low] = L[high];
		L[high] = tmp;
		while(low < high && L[low] <= key)
		{
			low++;
		}
		tmp = L[low];
		L[low] = L[high];
		L[high] = tmp;
	}
	return low;
}*/

void QuickSort(SqList &L,int low,int high)        //快速排序
{
	bool left = Left(L,low,high);
	bool right = Right(L,low,high) ;
	if(low < high)
	{
		int prvitloc = Partition(L,low,high);         //将数组一分为二
		if(!left)                                     //若左半部分没有进行数值交换
		{
			QuickSort(L,low,prvitloc-1);              //左半部分排序
		}
		if(!right)                                    //若右半部分没有进行数值交换
		{
			QuickSort(L,prvitloc+1,high);             //右半部分排序
		}
	}
}

int SelectMinKey(SqList &L,int n,int key)         //选择第key小的记录下标     
{
	for(int k = key+1;k < n;++k)                  //只比较key之后的
	{
		if(L[k] < L[key])                         //若小于则记录下标
		{
			key = k;
		}
	}
	return key;                                   //返回下标
}

void SelectSort(SqList &L,int n)                  //简单选择排序
{
	for(int i = 0;i < n-1;++i)
	{
		int j = SelectMinKey(L,n,i);              //第key小的记录位置
		if(i != j)                                //若不为此位置数，则交换位置
		{
			int tmp = L[i];
			L[i] = L[j];
			L[j] = tmp;
		}
	}
}

void Heapify(SqList &L,int low,int high)
{
	int sq = L[low];                         //将根结点保存在sq中
	for(int j = 2*low;j <= high;j *= 2)      
	{
		if(j < high && L[j] < L[j+1])        //沿关键字较大的孩子结点向下筛选
		{
			j++;                             //关键字较大节点下标
		}
		if(sq > L[j])                        //若孩子结点的值小于根结点的值，则不进行交换
		{
			break;
		}
		L[low] = L[j];
		low = j;
	}
	L[low] = sq;                             //将根结点插入到正确位置
}


void BuildHeap(SqList &L,int n)         //建立大顶堆
{
	for(int i = n/2;i > 0;i--)          //从序号n/2开始建立大顶堆
	{
		Heapify(L,i,n);
	}
}


void HeapSort(SqList &L,int n)
{                                       //对L[1..n]进行堆排序，不妨用L[0]做暂存单元
	BuildHeap(L,n);                     //将L[1-n]建成初始堆
	for(int i = n-1;i > 1;i--){ 
		                                //对当前无序区L[1..i]进行堆排序，共做n-1趟。
		L[0]=L[1];
		L[1]=L[i];
		L[i]=L[0];
		                                //将堆顶和堆中最后一个记录交换
		Heapify(L,1,i-1);
		                                //将L[1..i-1]重新调整为堆，仅有L[1]可能违反堆性质
	} 
} 

void main()
{
	SqList sq = {0,53,24,35,56,32,78,99}; 
	SqList sq2 = {53,24,35,56,32,78,99}; 
	for(int i = 0;i < 7; ++i)
	{
		cout<<sq2[i]<<" ";
	}
	cout<<endl;
	BubbleSort(sq2,7);                          //冒泡排序结果打印
	for(i = 0;i < 7; ++i)
	{
		cout<<sq2[i]<<" ";
	}
	cout<<endl;
	QuickSort(sq2,0,6);                         //快速排序
	for(i = 0;i < 7; ++i)
	{
		cout<<sq2[i]<<" ";
	}
	cout<<endl;
	SelectSort(sq2,7);                         //简单选择排序
	for(i = 0;i < 7; ++i)
	{
		cout<<sq2[i]<<" ";
	}
	cout<<endl;
	HeapSort(sq,8);
	for(i = 1;i < 8; ++i)
	{
		cout<<sq[i]<<" ";
	}
	cout<<endl;
}


黑の旋风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
排序算法：快速排序
12-22
1.快速排序的思想 先从数列中取出一个数作为基准数（简单起见就选第一个数） 分区过程：将比这个数大的数全放到他的右边，比他小的数全放到他的左边（分治） 再对左右两边的区重复第一步和第二部操作，直到各区间...
选择排序，快速排序
uytuytgu的博客
06-17 1418
快排的实现
选择排序与快速排序
yaohuiyaoo的博客
10-15 1642
1.选择排序：首先拿出一个数赋给临时变量，然后依次和后面的数比较，如果找到比拿出来的数小，就记录这个数的下标，把值赋给拿出这个数的临时变量，然后让临时变量和后面的比较，如果找到比这个临时变量下的就覆盖之前记录的下标，覆盖临时变量。代码如下 int[]array={9, 5, 4, 3, 2, 7, 1, 8}; for (int i = 0; i <array.Length-1; i++) { int min = array[i];//记录值，防止更改 int minid = i;
【C语言】【数据结构初阶】 选择排序 、快速排序（重点）- 详解
m0_71071692的博客
01-26 265
选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。我们可以对其做一个优化：我们一趟选择，同时选出最小的和最大的，而非只选出最小/最大的。但是选择排序的时间复杂度为O(n^2)，最好情况下，也为O(n^2)
选择与冒泡排序算法
yeyu_xing的博客
07-27 271
一、选择排序 1、Python lst = [5, 2, 10, 15, 9, 1, 6] print('排序前：{}'.format(' '.join([str(i) for i in lst]))) for i in range(len(lst) - 1): for j in range(i + 1, len(lst)): if lst[i] > lst[j]: lst[i], lst[j] = lst[j], lst[i] print('排序后
排序算法之冒泡法、选择法、快速排序
u010257931的博客
02-25 2104
前言 对一组数据进行排序在我们日常编程的过程中经常用到排序算法。下面就经常用到的冒泡法、选择法还有快速排序法进行一下回顾。 关于时间复杂的一个计算方法：（简单版） 步骤： 1、找到执行次数最多的语句 2、语句执行语句的数量级 3、用O表示结果 然后： 1、用常数1取代运行时间中的所有加法常数 2、在修改后的运行次数函数中，只保留最高阶项 3、如果最高阶项存在且不是1，那么...
高级算法设计实验4：快速排序
11-16
1、掌握快速排序随机算法的设计思想与方法。 2、熟练使用高级编程语言实现不同的快速排序算法。 3、利用实验测试给出不同快速排序算法的性能以理解其优缺点。 快速排序是算法导论中的经典算法。在本实验中，给定一...
选择排序、冒泡排序、快速排序、桶排序
01-08
选择排序 假设一个最小值，选出最小值，互换位置… 假设一个最小值以及最小值的下标 找出最小值以及最小值的下标 假设的最小值与找出的最小值换位 function selectSort(arr){ for (var n = 0; n < arr.length-1;...
C语言实现选择排序、冒泡排序和快速排序的代码示例
09-02
主要介绍了C++中实现选择排序、冒泡排序和快速排序的代码示例,例子带有执行时间统计还可以简单看一下效率对比,需要的朋友可以参考下
哈工大数据结构实验5_冒泡排序与快速排序
03-26
（1） 冒泡排序和快速排序； （2） 插入排序和希尔排序； （3） 选择排序和堆排序； （4） 递归和非递归的归并排序。 2． 产生不同规模和分布的数据，以 Excel 生成算法执行时间 T(n)关于输入规模 n 的曲线的形式，...
直接插入排序/快速排序/选择排序/冒泡排序(详细实现算法和性能比较)
03-20
数据结构---直接插入排序/快速排序/选择排序/冒泡排序(详细实现算法和性能比较)
简易的选择排序与快速排序
九点就去睡
09-05 654
掌握常用排序方法，学会不止掌握冒泡排序
内部排序实验作业
cai_4的博客
06-13 786
以下程序利用直接插入排序和冒泡排序算法实现输入数据的排序，请补充完整代码。 （填写答案时请注意：1）字符间不要有空格；2）答案中出现的变量名称严格区分大小写；3）答案中出现的点运算符“.“以及其他运算符号均为英文标点符号，请将输入法切换在英文半角状态下输入。） #include<stdio.h> #include<stdlib.h> #define MAXSIZE 50 typedef int KeyType;
四种常见的排序(冒泡、简单选择、直接插入、快速)
qq_59943770的博客
10-18 512
1、冒泡排序 static void BubBlingSort(params int[]array )//参数数组 { for (int i = 0; i < array.Length-1; i++)//冒泡的轮数 { bool a = true;//定义一个bool值 for (int j = 0; j < array.Length-1-i; j++)//依次遍
C++实现经典排序算法（二）——选择排序和快速排序
WJ_SHI的博客
07-15 430
俗话说得好：排序千万种，方便第一种，排序不规范，找bug两行泪。上次写了一篇关于插入排序和冒泡排序的博文，这次再来介绍一下选择排序法和快速排序法。 选择排序法，顾名思义就是将需要的数选择出来，再放到需要的地方。 ...
c语言选择排序程序,C语言实现选择排序、冒泡排序和快速排序的代码示例
weixin_30184337的博客
05-17 661
选择和冒泡#includevoid maopao(int a[],int len){int i,j,temp;for(i = 0;i < len - 1 ; i ++){//从第一个到倒数第二个for (j = 0 ; j < len - 1 - i ; j ++)//排在后的是已经排序的{if (a[j] > a[j + 1])//大的数换到后面去{temp = a[j];a[...
【数据结构之排序5】快速排序
偶尔e网事
10-21 2737
1、算法思想 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。 （1）分治法的基本思想 分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。 （2）快速排序的基本思想 设当前待排序的无序
选择排序和快速排序算法原理和Python实现
UESTC_C2_403的博客
07-06 1537
选择排序：这种排序算法思路比较简单，每一次都选出整个列表中的最小值或者最大值，下面以最大值为例子。如果给你一个列表[1,5,6,2]。 第一步：通过比较选出最大值6，需要检查4个元素 第二步：通过比较选出剩余元素列表的zui'd
快速排序，快速选择排序，选择排序的区别
湾区人工智能
11-18 3200
选择排序是对整体序列进行排序 快速排序也是对整体序列进行排序     快速选择算法是快速在未排序的数组中寻找第k小/大的元素 快速选择算法和快速排序的思想是找基准点 ， 在基准点左边的都比他小，然后在基准点右边的都比大这样 但是这两个算法的目的不同 所以实现起来会有不同  快速选择算法只要选择一侧进行迭代就好了 快速排序要两侧都迭代   选择排序：保持最小元素在最左侧，用最左侧的元...
阐述说明以下概念 1、简单排序： 2、希尔排序： 3、快速排序： 4、堆排序：
最新发布
06-06
1、简单排序：也称为基本排序，是一种简单的排序算法，包括冒泡排序、选择排序和插入排序。这些算法适用于小规模数据的排序，但在大规模数据排序时效率较低。 2、希尔排序：也称为缩小增量排序，是一种高效的排序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值