各种排序算法集锦

最新推荐文章于 2022-12-29 21:09:10 发布
最新推荐文章于 2022-12-29 21:09:10 发布
阅读量396 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lm9140802/article/details/78543944
版权

今天呢，我想给大家分享一下我自己总结的几种排序算法，我们可以一起探讨探讨大笑

1》直接插入排序

我们先来看一下插入排序的大概过程：

比如现在有一个乱序的数组：{48，62，35，77，55，14，35，98}

<1>tmp  =  62;  {48},blank, 35,77,55,14,35,98}; 

48是否大于tmp，如果大于，48后移到blank

（此时tmp要和-1位置的数字进行比较，但是-1已经越界了，所以直接将tmp赋给-1后面的位置）

如果小于等于tmp,则不做改变；tmp指向下一个待排序数字。

{48，62}，35，77，55，14，35，98}

<2>tmp  = 35;    {48,62},blank,77,55,14,35,98};

62>35,将62移至blank，48>35,将48后移至原来62的位置

（此时tmp要和-1位置的数字进行比较，但是-1已经越界了，所以直接将tmp赋给-1后面的位置）

{35，48，62}，77，55，14，35，98}

<3>tmp  = 77;    {35,48,62,}blank,55,14,35,98};

62<tmp，77放在62的后面

{35，48，62，77}，55，14，35，98}

<4>tmp  = 55;    {35,48,62,77},blank,14,35,98};

77>55，77移至blank的位置，62>55,62移至原来77的位置，48<=55,将55移至48的后面

{35，48，55，62，77}14，35，98}

<5>tmp  = 14;  {35,48,55,62,77,blank,35,98}; 

77>14,77移至blank位置，62>14,62移至原来77的位置，55>14,55移至原来62的位置

48>14,48移至原来55的位置，35>14，将35移至原来48的位置

此时已将是-1位置与tmp进行比较，由于已经走到越界了，将tmp放入-1位置的后面。

{14，35，48，55，62，77}，35，98}

<6>tmp  = 35;  {14,35,48,55,62,77},blank,98}; 

77>35,将77移至blank的位置，62>35,将62移至原来77的位置，55>35,将55移至原来62位置

48>35，将48移至原来55的位置，35<=35,将35移至35的后面。

{14，35，35，48，55，62，77}，98}

<7>tmp  = 98;  {14,35,3548,55,62,77},98}; 

77<=98,将98移至77的后面

{14，35，35，48，55，62，77，98}

思路：以第一个数字为基准，tmp保存待排序数字，从待排序数字的前一个数字进行比较，如果大于待排序

数字，则让待排序前一个数字的前一个数字与待排序进行比较，依次类推，直到有一个数字<=待排序数字

将待排序数字插入其后面，一个待排序数字比较完成

tmp保存下一个待排序数字，重复上一个动作。

我们再来看一下代码就很明了了，

void InsertSort(int *arr,int len)
{
	if(NULL == arr || len<=0)
	{
		return;
	}

	int i;
	int j;
	int tmp;
	
	for(i = 1;i<len;i++)
	{
		tmp = arr[i];
		for(j = i-1;j>=0;j--)
		{
			if(arr[j]>tmp)
				arr[j+1]=arr[j];
			else
				break;
		}
		arr[j+1]  = tmp;
	}
}

int main()
{
	int arr[]={48,62,35,77,55,14,35,98};
	int len = sizeof(arr)/sizeof(arr[0]);
	InsertSort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}

接下来我i们来分析以下它的稳定性，由于两个相同的数字在移动之前和移动之后的位置没有发生变化，所以

此排序是稳定排序。

稳定性：稳定（越有序越快）

时间复杂度：o(n^2)~o(n):最好的情况下是o(n);都只比较一次

****************************************************************************************************************************

****************************************************************************************************************************

希尔排序：

希尔排序是在是将待排序的关键字序列分成若干个较小的子序列，对子序列进行直接插入排序

在时间耗费上，比直接排序法的性能要好一点。举个例子：

接下来我们看一下代码是怎么实现的呢？？？？？

static void Shell(int *arr,int len,int gap)
{
	if(NULL == arr || len<=0)
	{
		return;
	}

	int i;
	int j;
	int tmp;

	for(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;
		}
		arr[j+gap] = tmp;
	}
}

void ShellSort(int *arr,int len)
{
	int gap[] = {4,2,1};
	for(int i = 0;i<sizeof(gap)/sizeof(gap[0]);i++)
	{
		Shell(arr,len,gap[i]);
	}
}

int main()
{
	int arr[] = {46,55,13,42,94,17,5,70};
	int len = sizeof(arr)/sizeof(arr[0]);
	ShellSort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}

	return 0;

}


稳定性：不稳定，存在跳跃性

时间复杂度：O(n^1.3)~O(n^1.5)

空间复杂度：O(1);

*****************************************************************************************************************

*****************************************************************************************************************

冒泡排序：

冒泡排序算是比较常用的排序了，我们经常会用到：

思路：反复扫描待排序序列，在扫描的过程中顺次比较相邻两个元素的大小，若逆序就交换位置

以升序为例：观察一趟冒泡排序


那么接下来我们来看一下代码是怎么实现的呢？？

void BubbleSort(int *arr,int len)
{
	if(NULL == arr || len<=0)
	{
		return;
	}

	for(int i = 0;i<len-1;i++)
	{
		for(int j = 0;j<len-1-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				int tmp = arr[j];
			    arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}

		}
	}
}

int main()
{
	int arr[] = {48,62,35,77,55,14,35,98,22,40};
	int len = sizeof(arr)/sizeof(arr[0]);
	BubbleSort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}

	return 0;
}

稳定性：不具有跳跃性，稳定

时间复杂度：o(n^2)

空间复杂度o(1)

***********************************************************************************************************

***********************************************************************************************************

选择排序：

思想：

第一趟简单选择排序时，从第一个待排序数字开始，通过n-1次关键字的比较，从n个记录中选出关键字最小

的记录，并和第一个记录进行交换

第二趟简单选择排序时，从第二个记录开始，通过n-2次关键字比较，从n-1个记录中找到关键字最小的记录，

并和第二个记录进行交换

*******

第i趟简单选择排序时，从第i个记录开始，通过n-i次关键字比较，从n-i+1个记录中找到关键字最小的记录

并和第i个记录进行交换

如此反复，经过n-1趟简单选择排序，将把n-个记录排好序，剩下一个最小记录直接放在最后，所以共需要

n-1趟简单选择排序

举个简单的例子：

看到了这个过程，大家应该对简单选择排序的过程有了一定的了解了，那么再来看一下它的代码实现

void SelectSort(int *arr,int len)
{
	if(NULL == arr || len<=0)
	{
		return;
	}

	int minindex;

	for(int i = 0;i<len-1;i++)
	{
		minindex = i;
		for(int j = i+1;j<len;j++)
		{
			if(arr[minindex] > arr[j])
				minindex = j;
		}

		if(minindex != i)
		{
			int tmp = arr[i];
			arr[i] = arr[minindex];
			arr[minindex] = tmp;
		}
	}
}

int main()
{
	int arr[] = {48,62,35,77,55,14,35,98};
	int len = sizeof(arr)/sizeof(arr[0]);
	SelectSort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}

	return 0;
}

稳定性：

不稳定：举个例子（3，3，2）

时间复杂度：最好，最坏都是o(n^2)

空间复杂度：o(1)

**************************************************************************************************

**************************************************************************************************

快速排序：

思想：从待排序记录中选取一个记录作为基准，通常是第一个，然后将其余比基准小的移动到基准

的前面，大于或等于基准的移动到基准的后面，结果将待排序分成两个子序列，这个过程叫做快排

的一次划分

步骤：假设待排序列为arr[low],arr[low+1],......arr[high]

首先保存基准数字tmp = arr[low],此时arr[low]的位置相当于空位，然后反复进行如下连个扫描过程

直到low和high相遇。

1》high从右向左进行扫描，直到arr[high]<tmp时，将arr[high]移至空单元arr[low],此时arr[high]相当于

空单元

2》low从左向右进行扫描，直到arr[low]>tmp时，将arr[low]移至空单元arr[high],此时arr[low]相当于

空单元

当low和high相遇时，arr[low](或者arr[high])相当于空单元，左边都比它小，右边都比它大，最后将

基准放入其中，完成了快排的一次划分

我们首先来看一个例子，了解一下这个过程：

看了快排的大概过程，那我们再看一下它的代码实现：

#include <iostream>
#include <assert.h>
using namespace std;
static int partition(int *arr,int low,int high)
{
	assert(arr!=NULL);

	int tmp = arr[low];

	while(low<high)
	{
		while((low<high)&&arr[high]>=tmp)
			high--;
		if(low == high)
			break;
		else
			arr[low] = arr[high];

		while((low<high)&&arr[low]<=tmp)
			low++;
		if(low == high)
			break;
		else
			arr[high] = arr[low];
	}

	arr[low] = tmp;
	return low; 
}

static void Quick(int *arr,int low,int high)
{
	if(NULL == arr)
		return;

	int par = partition(arr,low,high);
	
	if(low<par-1)
		Quick(arr,low,par-1);
	if(par<high-1)
		Quick(arr,par+1,high);
}

void QuickSort(int *arr,int len)
{
	if(NULL == arr || len<=0)
		return;
	Quick(arr,0,len-1);
}

int main()
{
	int arr[] = {48,62,35,77,55,14,35,98};
	int len = sizeof(arr)/sizeof(arr[0]);
	QuickSort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}

	return 0;
}


稳定性：存在跳跃性，所以不稳定

时间复杂度：

时间复杂度：                  最好情况：             最坏情况：               空间复杂度：

nlogn                                nlogn                         n^2                           logn

快速排序的优化：

<1>三分取中法（选择基准）：优化有序的数据

具体思想：在选取基准时，可以从左中右三个中选取，对它们三个位置上的数据进行排序

取它们中间的那个数据作为基准，并用0下标元素存储基准。

举例：8 1 4 9 6 3 5 2 7 0；

左为8，右为0，中间为6；

在一次分割结束后，可以把与key相等的元素聚在一起，下次分割的时候，不再对相等元素

进行分割。

举例：

待排序列：1  4  6  7  6   6  7  6  8  6

三数取中选取基准：下标为4的6；

一次划分后：对与key相同的元素进行处理：

1  4 6 6 6 6 6 7 8 7

下次划分的两个子序列：1 4和7 8 7；

具体过程：

第一步：在划分的过程中，把与基准值相等的数字放入数组的两端

第二步：划分结束后，把与基准值相同的数字移动到基准值的周围《减少重复》

举例：

待排序列;1 4 6 7 6 6 7 6 8 6

基准值：下标为4的6；

转换后，带分割序列： 6 （基准）    4 6 7 1 6 7 6 8 6

第一步：再划分过程中，把与基准值相等的数字放入数组的两端

结果为：6 4 1         6（基准）       7 8 7 6 6 6

第二步：划分结束后，把与基准值相等的数字移动到基准值周围 

结果：1 4 6    6（基准）   6 6 6 7 8 7

之后：在14和7 8 7两个子序列进行快排。

void swap(int arr[],int first_index,int second_index)
{
	int tmp = arr[first_index];
	arr[first_index] = arr[second_index];
	arr[second_index] = tmp;
}


int changeSeondMaxNumber(int *arr,int low,int high)
{
	int mid = low+((high-low)>>1);

	if(arr[high] <arr[mid])
	{
		swap(arr,mid,high);
	}

	if(arr[low] <arr[mid])
	{
		swap(arr,mid,low);
	}

	if(arr[low] <arr[high])
	{
		swap(arr,high,low);
	}
    /*
	   low的位置保存这三个位置上的中间值
	   分割时可以直接使用low位置的元素作为基准
	   而不用改变分割函数了。
	*/
	
	return arr[low];
}

void Qsort(int *arr,int low,int high)
{
	int first = low;
	int last = high;

	int left = low;
	int right = high;

	int leftlen = 0;
	int rightlen = 0;

	if(high-low+1<10)
	{
		InsertSort(arr,low,high);//如果数小于10个，就用直接插入法
	}

	//一次分割//使用三数取中法选择基准
	int key = changeSeondMaxNumber(arr,low,high);
	while(low<high)
	{
		while(high>low&&arr[high]>=key)
		{
			if(arr[high] == key)//处理相等元素
			{
				swap(arr[right],arr[high]);
				right--;
				rightlen++;
			}
			high--;
		}
		arr[low] = arr[high];
		while(high>low&&arr[low]<=key)
		{
			if(arr[low] == key)
			{
				swap(arr[left],arr[low]);
				left++;
				leftlen++;

			}
			low++;
		}
		arr[high] = arr[low];
	}
	arr[low] = key;
	//一次快排结束
	//把与基准key相同的元素移动到最终位置周围
	int i = low-1;
	int j = first;
	while(j<left&&arr[i]!=key)
	{
		swap(arr[i],arr[j]);
		i--;
		j++;
	}

	i = low+1;
	j = last;
	while(j>right&&arr[i]!=key)
	{
		swap(arr[i],arr[j]);
		i++;
		j--;
	}

	Qsort(arr,first,low-1-leftlen);
	Qsort(arr,low+1+rightlen,last);


}

******************************************************************************************************

*****************************************************************************************************

堆排序：

堆排序的过程主要需要解决两个问题：一是按堆定义建初堆，二是去掉最大元之后重建堆，

得到次大元，依次类推

我们以大根堆为例：

问题一：

当堆顶记录改变时，如果重建堆：

首先将与堆相应的完全二叉树根节点中的记录移出，该记录被称为待调整记录，此时根节点相当于空节点

从空节点的左右子树中选出一个关键字较大的记录，如果该记录的关键字大于待调整记录的关键字，则将

该记录上移至空节点当中，此时，原来那个关键字较大的节点相当于空节点，从空节点的左右子树中选取

一个关键字较大的记录，如果该记录的关键字仍大于待调整的关键字，则将该记录上移至空节点。

重复上述移动过程，直到空节点左右子树的关键字均小于待排序记录的关键字，，此时，将待调整记录放入

空节点即可

举例：

             


   




//一次堆调整
void Adijust(int *arr,int start,int end)
{
	int tmp = arr[start];
	int parent = start;
	for(int i = 2*start+1/*父到子*/;i<=end;i=2*i+1/*右孩子*/)
	{
		if((i+1<=end)&&(arr[i])<arr[i+1])
			i++;//i为左右孩子较大的值的下标
		if(tmp<arr[i])
		{
			arr[parent] = arr[i];
			parent = i;
		}
		else
			break;
	}
	arr[parent] = tmp;
}


2：建立大根堆：

思想：将一个任意序列看成完全二叉树，由于叶节点可以视为单元素的堆，因而可以反复利用上述调整

堆算法，自底向上逐层把所有的子树调整为堆，直到将整个完全二叉树调整为堆

可以证明，最后一个非叶节点位于第n/2个位置，

举例：

   

  




//建立大根堆
void HeapSort(int *arr,int len)
{       
        if(NULL == arr)
           return;

	int i;
	for(i = (len-1)/2;i>=0;i--)
	{
		Adjust(arr,i,len-1);

	}

	int tmp;
	for(i = 0;i<len-1;i++)
	{
		tmp = arr[0];
		arr[0] = arr[len-1-i];
		arr[len-1-i] = tmp;
		Adjust(arr,0,len-1-i-1);
	}
}


稳定性：不稳定

时间复杂度                        最好                          最坏                    空间

o(nlogn)                             o(nlogn)                     o(nlogn)             o(1)





lm9140802
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
各种排序代码
11-08
第一次上传！！希望大家喜欢！
各种常见排序代码整理
花花世界
10-28 458
插入、冒泡、选择、快速
【算法】直接插入排序
学习 - 总结 - 分享 - Francis
10-30 648
1.定义每次从无序表中取出第一个元素 把它插入到有序表的合适位置，使有序表仍然有序
c语言编写排序算法——直接插入排序（附详细代码）
qq_62185081的博客
12-29 5658
先将第一个记录看作是一个有序的记录序列，然后从第二个记录开始，依次将未排序的记录插入到这个有序的记录序列中去，直到整个文件中的全部记录排序完毕。为了讨论简单，假设待排序的每个记录是一个整数，这个整数就是排序码。后面的记录是待排序的。中的序列是有序序列，
排序算法详细讲解（超酷）
热门推荐
qq_51419787的博客
03-30 1万+
排序算法作为数据结构中重要的部分，是必须要掌握的知识之一。 目录 前言 一、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 二、交换类排序 1.冒泡排序（相邻比序法） 2.快速排序 三、选择类排序 1.简单选择排序 2.树形选择排序 3.堆排序 四、归并排序 五、分配类排序 1.多关键字排序 2.链式基数排序 3.计数排序 总结 前言 在进行数据处理时，经常需要对数据进行查找，为了查的更快，通常要求数据有序排列。根据排序时......
各种排序算法比较.doc
09-20
接着，我们对比各种排序算法的性能。插入排序和冒泡排序虽然在最坏情况下时间复杂度较高，但在部分有序的数据集上表现优秀。选择排序在任何情况下都保持固定的时间复杂度，但不稳定。快速排序在大多数情况下表现出色...
PHP 各种排序算法实现代码
01-20
php // 功能: PHP实现各种排序算法 // Author: windlike // Datetime: 2007-06-09 // 冒泡排序 function BubbleSort($arr){ $num = count($arr); for($i=1;$i<$num;$i++){ for($j=$num-1;$j>=$i;$j–){ if($arr[$...
各种排序算法的详细分析
03-22
此为一个利用Java语言编写的排序分析程序，程序中统计了各种排序算法（冒泡排序、选择排序、插入排序、希尔排序、快速排序、堆排序、归并排序、基数排序）的分析，ppt中包含各种排序算法的分析，附上动画演示（来自...
C++实现各种排序算法.zip
10-10
本资料包"**C++实现各种排序算法.zip**"提供了C++语言实现的多种排序算法，这对我们深入理解和运用这些算法具有重要意义。 首先，让我们探讨一下**排序算法**的基本概念。排序是指将一组数据按照特定顺序排列的过程...
Java各种排序算法代码.zip
05-31
这个名为"Java各种排序算法代码.zip"的压缩包包含了一系列实现不同排序算法的Java源代码。排序算法是计算机科学中的基本概念，用于对一组数据进行排列。下面将详细讨论这些算法及其在Java中的实现。 1. 冒泡排序...
排序算法之快速排序
信念随梦的博客
12-15 402
基本思想： 1）选择一个基准元素,通常选择第一个元素或者最后一个元素, 2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。 3）此时基准元素在其排好序后的正确位置 4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。 下面我们通过一个案例来演示一下快速排
排序算法--交换篇（冒泡，快排）
dazzlingN的博客
10-06 474
1.冒泡排序 算法思想：反复扫描待排序记录序列，在扫描的过程中顺次比较相邻的两个元素的大小，若逆序就交换位置。第一趟排序不断地将相邻两个记录中关键字大的记录向后移动，第二趟将前n-1个记录进行同样的操作，结果次大的记录被放在n-1个记录的位置。如此反复，每趟排序都将一个记录排序到位，直到剩下一个最小的记录。 private static void BubbleSort(int[] a) {...
排序的基本概念
学习日常分享
06-20 362
是将一组具有相同数据类型的数据元素调整为按关键字从小到大或从大到小排列的过程。 主关键字：得到的排序结果唯一。 次关键字：排序结果不一定唯一。 数据项组合：排序结果不一定唯一。 例如： 待排序序列： {48,62,35,77,55,14,35,98,22,40} 排序结果序列： {14,22,35,35,40,48,55,62,77,98} {14,22,35,35,40,48,55,62,77,98}内部排序：整个排序过程完全在内存中进行。 外部排序：待排序记录数据量太大，内存无法容纳全部数据，排序需要借
数据结构————查找与排序
pc的博客
09-14 2309
复习了几遍数据结构，线性表、栈、队列、串、数组、广义表、树、图、查找和排序。发现查找和排序算法很容易忘，而且这些算法又是很经典的，其他的掌握结构体和指针稍微好一点，想在此写下查找和排序算法，让自己更深刻，很多都不好写，所以有些就没写。 查找 1.基于线性表查找法 静态查找表 不对表做插入和删除 顺序查找法 ： ...
排序算法
汐梦的博客
09-02 235
数据结构复习一—–排序算法 这是数据结构中有的相关的排序算法 插入类排序 直接插入类排序 将第i个记录插入已经排好序的i-1个元素中，每次依次比较和移动，i从2-n（第一个视为已经排好序的元素），保留一个key存放array[i]的数据，以防数据大的元素后移使会覆盖掉要插入的数据。 每次只要找到比要插入的数据大的数据就交换两个元素的位置 代码块 vo...
快速排序
05-11 411
#include using namespace std; /* 快速排序需要选择一个基准数，一趟排序过程就是将所有数按与这个基准数的大小关系排序的过程：大的放到右边， 小的放到左边。按照这个思路再不断分治。 */ int array[] = {48,62,35,77,55,14,35,98}; int OneTimeSort(int * a,int left,int right) {
经典排序算法
ChanCherry的博客
06-07 806
算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O（nlogn），因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 ...
【创新未发表】Matlab实现遗传算法GA-RF实现风电预测算法研究.rar
最新发布
08-02
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
蚁群算法（培训）.pdf
08-02
蚁群算法（培训）.pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值