排序算法总结

最新推荐文章于 2022-01-08 19:26:07 发布
最新推荐文章于 2022-01-08 19:26:07 发布
阅读量624 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XHfight/article/details/53236002
版权
下面是九大排序算法的总体分类：
接下来，对每个排序算法进行分析：

一、直接插入排序(straight insertion sort)：
1.算法思想：将数据插入到已经排好的序列中。有序序列初始只有一个元素，将下一个的元素插入，有序队列增长， 直到最后整个要排序的队列都有序。
2.时间复杂度：
最好时间复杂度：O(N) ：原有数据已经有序
最坏时间复杂度O(N^2)：原有数据完全或接近逆序
3.应用场景：适用于元素已经基本有序，不适用于元素逆序或接近逆序的情况。
4.代码实现：
代码包含两个for循环， 第一个标记当前要插入的元素位置， 第二个为单趟插入，将要插入的元素插入到有序序列中。 
//插入排序
void InsertSort(int* arr, size_t size)
{
	assert(arr);
	for(size_t j = 1; j < size; ++j)//要插入数据的位置
	{
		int insert = arr[j]; //要插入的数据
		int i = j-1;
		for( ; i >= 0 ;--i) //单趟插入
		{
			if(arr[i] > insert)
				arr[i+1] = arr[i];
			else
				break;
		}
		arr[i+1] = insert;
	}
}

二、希尔排序(Shell Sort)，又名缩小增量排序：
当要排序的数据列完全或接近逆序时，用插入排序时间复杂度接近O(N^2)，为了优化这种情况，减少插入时的数据移动，提出了希尔排序。
1.算法思想：将数据分组，对每组的数据进行插入排序，然后缩小分组的大小再进行插入排序，直到分组大小为1，则要排列的数据有序。（预排序+插入排序）
2.时间复杂度：
3.应用场景：适用于元素接近逆序， 不适用于元素基本有序的情况。
4.代码实现：
gap为每组的大小，当gap=1时，相当于插入排序，gap的最小值为1. 
//希尔排序
void ShellSort(int* arr, size_t size)
{
	assert(arr);
	int gap = size;
	while(gap != 1)
	{
		gap = gap/3 + 1;
		for(size_t j = gap; j < size; ++j)
		{
			int insert = arr[j];
			int i = j-gap;
			for( ; i>=0; i-=gap)
			{
				if(arr[i] > insert)
					arr[i+gap] = arr[i];
				else
					break;
			}
			arr[i+gap] = insert;
		}
	}
}

三、选择排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
void SelectSort(int* arr, size_t size)
{
	assert(arr);
	int left = 0;
	int right = size-1;
	while(left < right)
	{
		size_t max = left; //记录最大值的下标
		size_t min = left;
		for(int i = left; i <= right; ++i)
		{
			if(arr[i] > arr[max])
				max = i;
			if(arr[i] < arr[min])
				min = i;
		}
		swap(arr[left], arr[min]);
		//注意：防止上面的交换使max值不正确。
		//当max的值为左时，交换会让max值改变，这里要调整。
		if(left == max) 
			max = min;
		swap(arr[right], arr[max]);
		left++;
		right--;
	}
}

四、堆排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
void AdjustDown(int* arr, size_t size, size_t parent)
{
	size_t child = parent*2+1;
	while(child < size)
	{
		if(child+1<size && arr[child+1] > arr[child])
			++child;
		if(arr[parent] < arr[child])
			swap(arr[parent], arr[child]);
		else
			break;
		parent = child;
		child = parent*2+1;
	}
}

//堆排序
void HeapSort(int* arr, size_t size)
{
	assert(arr);
	//建堆
	int parent = (size-1-1)/2;
	while(parent >= 0)
	{
		AdjustDown(arr, size, parent);
		parent--;
	}
	//排序
	int index = size-1;//记录交换的位置
	while(index>0)
	{
		swap(arr[0], arr[index]);
		AdjustDown(arr, index, 0);
		--index;
	}

五、冒泡排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
void BubbleSort(int* arr, size_t size)
{
	assert(arr);
	for(size_t i = 0; i<size-1; ++i)
	{
		for(size_t j = 1; j < size-i; ++j)
		{
			if(arr[j-1] > arr[j])
			{
				swap(arr[j-1],arr[j]);
			}
		}
	}
}

六、快速排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
//快速排序
//优化一：三数取中法
size_t GetMid(int* arr, size_t left, size_t right)
{
	size_t mid = left+((right-left)>>2);
	if(arr[left] < arr[mid])
	{
		if(arr[mid] < arr[right])
			return mid;
		else if(arr[left] < arr[right])
			return right;
		else
			return left;
	}
	else  //left大
	{
		if(arr[left] < arr[right])
			return left;
		else if(arr[right] < arr[mid])
			return mid;
		else
			return right;
	}
}
//法1：左右指针
size_t PartSort1(int* arr, size_t left, size_t right)
{
	size_t key = right;
	size_t mid = GetMid(arr, left, right);
	if(key != mid)
		swap(arr[key], arr[right]);
	while(left < right)
	{
		//left找大
		while(left < right && arr[left] <= arr[key])
			++left;
		while(left < right && arr[right] >= arr[key])
			--right;
		swap(arr[left], arr[right]);
	}
	if(right != key)
		swap(arr[left], arr[key]);
	return left;
}

//法2：挖坑法
size_t PartSort2(int* arr, size_t left, size_t right)
{
	int key = arr[right];
	while(left < right)
	{
		while(left < right && arr[left] <= key)
			++left;
		arr[right] = arr[left];

		while(left < right && arr[right] >= key)
			--right;
		arr[left] = arr[right];
	}
	//right == left
	arr[right] = key;
	return right;
}

//法3：前后指针法
size_t PartSort3(int* arr, int left, int right)
{
	int cur = left-1;
	int prev = left-1;
	int key = right;
	while(cur < right)
	{
		while(cur < right && arr[++cur] >= arr[key]);//cur找小
		++prev;
		swap(arr[prev], arr[cur]);
	}
	return prev;
}

void QuickSort(int* arr, size_t left, size_t right)
{
	assert(arr);
	if(right-left > 0)
	{
		//优化二：区间数量较少时，用插入排序替代递归
		if(right-left > 5)  
		{
			int div = PartSort3(arr, left, right);
			//[left, div-1] [div+1, right]
			if(div != left) //注意：当div为边界时，边界的一边不需要继续排序
				QuickSort(arr, left, div-1);
			if(div != right)
				QuickSort(arr, div+1, right);
		}
		else
		{
			InsertSort(&arr[left], right-left+1);
		}
	}
}

七、归并排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
//[left, right]
void MSort(int* arr,int* tmp, int left, int right)
{
	if(right - left > 0)
	{
		int mid = left+(right-left)/2;
		MSort(arr, tmp, left, mid);
		MSort(arr, tmp, mid+1, right);
		
		//合并
		int begin1 = left, end1 = mid;
		int begin2 = mid+1, end2 = right;
		int i = left;
		while(begin1<=end1 && begin2<= end2)
		{
			if(arr[begin1] < arr[begin2])
			{
				tmp[i++] = arr[begin1];
				++begin1;
			}
			else
			{
				tmp[i++] = arr[begin2];
				++begin2;
			}
		}
		while(begin1 <= end1)
		{
			tmp[i++] = arr[begin1];
			++begin1;
		}
		while(begin2 <= end2)
		{
			tmp[i++] = arr[begin2];
			++begin2;
		}
		for(int j = left; j <= right; ++j)
		{
			arr[j] = tmp[j];
		}
	}

}
void MergeSort(int* arr, size_t size)
{
	assert(arr);
	int* tmp = new int[size];
	MSort(arr, tmp, 0, size-1);
	delete[] tmp;
}

八、计数排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
//1.计数排序:利用哈希的直接定址法，适用于数据比较集中的排序
void CountSort(int* arr, size_t size)
{
	assert(arr);
	int max = arr[0];
	int min = arr[0];
	for(int i = 1 ; i < size; ++i)
	{
		if(arr[i] > max)
			max = arr[i];
		if(arr[i] < min)
			min = arr[i];
	}
	int range = max - min + 1;
	int* tmp = new int[range];//存储每个数据出现的次数
	memset(tmp, 0, sizeof(tmp[0])*range);
	for(int i = 0; i < size; ++i)
	{
		tmp[arr[i] - min]++;
	}

	int j = 0;
	for(int i = 0; i < range; ++i)
	{
		while(tmp[i]--)
		{
			arr[j++] = min + i;
		}
	}
	delete[] tmp;
}

九、基数排序：
1.算法思想：
2.时间复杂度：
3.适用场景
4.代码实现： 
//2.基数排序
// 最高位优先 -- MSD
// 最低位优先 -- LSD
//
void MSDSort(int* arr, size_t size)
{
	assert(arr);
	int max = arr[0];
	for(int i = 1; i < size; ++i)
		if(arr[i] > max)
			max = arr[i];
	
	//统计最大位数
	int digit = 1; //最大位数
	int div = 10;
	while((max / div) > 0)
	{
		++digit;
		div *= 10;
	}
	
	//从低位到高位排序
	int* beginIndex = new int[10];//记录每个桶的开始下标
	int* tmp = new int[size];
	
	div = 1;
	while(digit--)
	{
		//统计每个桶的开始下标
		memset(beginIndex, 0, sizeof(beginIndex[0])*10);
		
		for(int i = 0; i < size; ++i)//统计每个桶的数据个数
		{
			size_t index = (arr[i]/div) % 10;
			beginIndex[index]++;
		}
		int index = 0;
		for(int i = 0; i < 10; ++i)//计算每个桶的开始下标
		{
			int count = beginIndex[i];
			beginIndex[i]  = index;
			index += count;
		}

		//将单次排序数据写入临时数组
		for(int i = 0; i < size; ++i)
		{
			size_t index = (arr[i]/div) % 10;
			tmp[beginIndex[index]++] = arr[i];
		}
	
		div *= 10;
		//将tmp的数据拷贝到arr中
		for(int i =0 ;i < size; ++i)
		{
			arr[i] = tmp[i];
		}
	}

	delete[] beginIndex;
	delete[] tmp;
}


XHfight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法总结
01-24
常用排序算法总结，包括插入排序(InsertionSort)，冒泡排序(BubbleSort)，选择排序(SelectionSort)，快速排序（QuickSort)， * 二路归并排序(MergeSort)，堆排序(HeapSort)。有每一种排序算法的复杂度分析以及实现思路~
常用排序算法总结
11-06
### 常用排序算法总结 #### 一、冒泡排序 冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复进行的，直到没有再需要...
C#排序算法总结
09-18
C#排序算法总结：交换排序：最基础的冒泡排序，冒泡排序的优化版选择排序和快速排序，插入排序：直接插入排序和折半插入排序。
Java排序算法总结
12-22
【Java排序算法总结】 在计算机科学中，排序算法是用于对数据进行排列的算法，而Java作为一种广泛应用的编程语言，提供了多种实现排序的方案。以下是对几种常见的Java排序算法的详细解析： 一、冒泡排序 冒泡排序...
排序算法汇总总结
GarfieldEr007的专栏
01-08 273
一、插入排序 直接插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 代码实现： #include <stdio.h> #include <stdlib.h> void swap(i
排序算法总结（一）
十年磨一剑，沉淀……
06-10 1800
【前言】 前一阵子直在学习算法，通过不断的总结我也发现了算法的魅力。虽然只是简单的排序算法，但是每一次自己动手去画图，去排列对比，看一些相关小视频的时候，感触就会越来越深，从刚开始的只不过简简单单的排序到后来升华成算法的艺术，需要自己慢慢去体会这个过程。 排序主要分为内排序和外排序，如果待排序的记录比较少，整个过程的所有记录都可以存在内存中，这样的排序叫做“内排序”。...
排序算法总结整理
jy0921
02-08 183
各种排序算法的稳定性和时间复杂度小结   目前不太清楚 ：时间复杂度 考虑 比较 和 移动的问题，分开考虑？    1. 冒泡排序的时间复杂度： 平均O(n2)        最坏O(n2)      最好O(n)                空间复杂度 O(1)           稳定，简单 package test; public class Index { public ...
快速排序及其优化
宇哲
11-23 2544
我们今天来研究下快速排序，快速排序的一个整体的思想就是分治的思想，在这个过程当中，首先对一个大区间进行单趟快速排序，然后把大区间分成多个区间，再去进行单趟排序，一直到这个区间中的元素只剩下一个元素，这样重复以后就可以得到最后的排序后的结果。 1.单趟排序分析快速排序的最重要的就是单趟排序，接下来就是进行分治的单趟排序，所以我们来重点说一下单趟排序。我们在这里介绍关于快速排序的单趟排序的三种方法。左
1.常用排序算法总结
aaron的博客
02-02 1万+
序 常见的排序算法有8种： 表格： 排序方法 时间复杂度（平均） 时间复杂度（最坏) 时间复杂度（最好) 空间复杂度 稳定性 冒泡排序 O(n2) O(n2) O(n) O(1) 稳定 直接选择排序 O(n2) O(n2) O(n2) O(1) 不稳定 直接插入排序 O(n2) O(n
JavaScript十种排序算法总结
weixin_42572968的博客
03-25 508
十种排序对比 排序的分类 1 冒泡排序（BubbleSort） 特点：稳定排序（stable sort）、原地排序（In-place sort） 思想：通过两两交换，像水中的泡泡一样，小的先冒出来，大的后冒出来。 最坏运行时间：O(n^2) 最佳运行时间：O(n^2)（当然，也可以进行改进使得最佳运行时间为O(n)） 冒泡排序算法的运作如下：（从后往前） （1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。 （2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应
各种排序算法总结(全面)
zxzxin的博客~
04-05 2万+
目录 冒泡排序 改进的冒泡排序(鸡尾酒排序) 选择排序 插入排序 二分插入排序 希尔排序 快速排序 归并排序 堆排序 计数排序 基数排序 桶排序 基本概要 排序算法大体可分为两种： 一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 另一种是非比较排序，时间复杂度可以达到O(...
九大排序算法再总结
热门推荐
xiazdong
01-03 30万+
如果要转载，需要注明出处： http://blog.csdn.net/xiazdong 本文是 http://blog.csdn.net/xiazdong/article/details/7304239 的补充，当年看了《大话数据结构》总结的，但是现在看了《算法导论》，发现以前对排序的理解还不深入，所以打算对各个排序的思想再整理一遍。 本文首先介绍了基于比较模型的排序算法，
数据结构详解：排序算法总结与复杂性分析
本资源是一份关于常用排序算法总结的PPT课件，主要涵盖了数据结构中的排序理论和实践。章节9详细介绍了排序的基本概念，包括排序的定义，即通过特定规则重新排列数据，使其满足非递减关系。排序被划分为稳定和不稳定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值