数据结构与算法06

Lnitial_1

于 2022-08-27 14:16:48 发布

阅读量44

点赞数

文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/weixin_56293040/article/details/126557621

版权

数据结构与算法

排序算法：

排序算法的稳定性：

在待排序的数据中，如果有值相同的数据，在排序的全程中都不会改变它们的先后顺序，则认为该排序算法是稳定的

//	类型宏定义
#define TYPE int
//	交换宏
#define swap(a,b) {typeof(a) t=(a);(a)=(b);(b)=t;}

冒泡排序：

数据左右进行比较，把最大的数一直交换到最后，特点是该算法对数据的有序性是敏感,在排序过程中发现有序可以立即停止排序，则冒泡的效率非常高

时间复杂度： 最优O(n) 平均： O(n^2)

稳定性： 稳定

//	冒泡排序
void bubble_sort(TYPE* arr,size_t len)
{
	//	标志位用于判断排序是否完成，可以提前继续排序
	bool flag = true;
	for(int i=len-1; i>0 && flag; i--)
	{
		flag = false;
		for(int j=0; j<i; j++)
		{
			if(arr[j] > arr[j+1])
			{
                //	数据交换
				swap(arr[j],arr[j+1]);	
				flag = true;
			}
		}
	}
}

选择排序：

假定最开始的位置是最小值并记录下标min，然后与后面的数据比较，如果有比min为下标的数据还要小，则更新min，最后判断min的值发生了改变，则交换min位置的数据与最开始位置的数据

虽然选择排序的时间复杂度较高，但是数据交换次数少，因此实际运行速度并不满

是冒泡排序的变种，但是没有对数据有序性敏感，数据混乱情况下比冒泡快

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

稳定性：不稳定的

注意：算法的时间复杂度并不能代表算法的实际时间，有时候时间复杂度高的反而速度更快

//	选择排序
void select_sort(TYPE* arr,size_t len)
{
	for(int i=0; i<len-1; i++)
	{
		int min = i;
		for(int j=i+1; j<len; j++)
		{
			if(arr[j] < arr[min]) min = j;	
		}
		if(i!=min) swap(arr[i],arr[min]);
	}
}

插入排序：

把数据看作两个部分，一部分是有序的，把剩余的数据逐个插入进去

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

稳定性： 稳定

//	插入排序
void insert_sort(TYPE* arr,size_t len)
{
	//	i是待插入的数据下标
	for(int i=1,j=0; i<len; i++)
	{
		int val = arr[i];
		//	在有序部分找合适的位置插入
		for(j=i-1; j>=0 && arr[j]>val; j--)
		{
			arr[j+1] = arr[j];	
		}
		if(j+1 != i) arr[j+1] = val;
	}
}

希尔排序：

是插入排序的增强版，由于插入排序移动速度比较慢，所以在此基础上增加了增量的概念，从而提高排序的速度

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

稳定性：不稳定

//	希尔排序
void shell_sort(TYPE* arr,size_t len)
{
	for(int k=len/2; k>0; k/=2)
	{
		//	i是待插入的数据下标
		for(int i=k,j=0; i<len; i++)
		{
			int val = arr[i];
			//	在有序部分找合适的位置插入
			for(j=i-k; j>=0 && arr[j]>val; j-=k)
			{
				arr[j+k] = arr[j];	
			}
			if(j+k != i) arr[j+k] = val;
		}
	}
}

快速排序：

找到一个标杆，备份标杆p的值val，一面从左找val大的数据，找到后赋值给p，更新标杆p的位置到左标杆，然后继续从右边找比val小的数，找到后也赋值给p，同样更新p到右标杆。反复执行直到左右标杆相遇，把val赋值回p的位置。最终回形成p左边的数都比它小，右边的数都比它大；然后再按照同样的方式对左右两边进行快排，最后全部有序

快速排序的综合性能最高

时间复杂度: O(NlogN)

稳定性： 不稳定

//	快速排序依赖函数
void _quick_sort(TYPE* arr,int left,int right)
{	
	if(left >= right) return;

	//	计算标杆下标
	int pi = (left+right)/2;
	//	备份标杆的值
	TYPE pv = arr[pi];
	//	备份左右标杆下标
	int l = left, r = right;

	while(l < r)
	{
		//	在pi左边找比pv大的数据
		while(l<pi && arr[l]<=pv) l++;
		if(l < pi)
		{
			//	找到了比pv大数
			arr[pi] = arr[l];
			//	更新pi
			pi = l;
		}
		
		//	从pi右边找比pv小的数
		while(r>pi && arr[r]>=pv) r--;
		if(r > pi)
		{
			//	找到比pv小的数
			arr[pi] = arr[r];
			//	更新pi
			pi = r;
		}
	}
	//	pi左边小于pv  右边大于pv
	//	还原pv
	arr[pi] = pv;
	if(pi - left > 1) _quick_sort(arr,left,pi-1);
	if(right - pi >1) _quick_sort(arr,pi+1,right);
}

//	快速排序
void quick_sort(TYPE* arr,size_t len)
{
	_quick_sort(arr,0,len-1);
}

归并排序：

先把一组待排序的数据拆分成单独的个体，存放到临时空间中，然后两两比较合并，全部合并完成后再从临时空间中拷贝原内存

由于需要使用使用的内存空间避免了数据交换的耗时，是一种典型的以空间换时间的算法

时间复杂度： O(NlogN)

稳定性： 稳定的

//	拆分合并 从l到r进行归并
void _merge_sort(TYPE* arr,TYPE* tmp,int l,int r)
{	
	if(l >= r) return;
	int p = (l+r)/2;
	//	对左部分归并
	_merge_sort(arr,tmp,l,p);
	//	对右部分归并
	_merge_sort(arr,tmp,p+1,r);

	//	左右部分各自有序
	//	l左部分最左 p左部分最右  p+1右部分最左 r右部分最右
	if(arr[p] <= arr[p+1]) return;

	int i = l, j = p+1, k = l;
	while(i<=p && j<=r)
	{
		if(arr[i] <= arr[j])	//一定是<= 才能稳定
			tmp[k++] = arr[i++];
		else
			tmp[k++] = arr[j++];
	}
	//	比完后还没比较的放入tmp末尾
	while(i<=p) tmp[k++] = arr[i++];
	while(j<=r) tmp[k++] = arr[j++];
	memcpy(arr+l,tmp+l,sizeof(TYPE)*(r-l+1));
}

//	归并排序
void merge_sort(TYPE* arr,size_t len)
{
	TYPE* tmp = malloc(sizeof(TYPE)*len);
	_merge_sort(arr,tmp,0,len-1);
	free(tmp);
}

堆排序:

（1）根结点为最大值，则接下来需要将根结点与末尾子结点交换
（2）对根结点进行最大堆调整（已交换的末尾结点不参与调整），使得根结点为下一个最大值
（3）最后通过不断的交换，缩小最大堆调整的范围到只剩下根结点后，即可完成整个序列的排序

时间复杂度：O(NlogN)

稳定性：不稳定

顺序实现：

//	堆排序 顺序实现
void sort_heap(int* arr,int len)
{
	//	把数组调成堆结构
	for(int i=1; i<=len; i++)
	{
		int j=i;
		while(j > 1)
		{
			if(arr[j-1] > arr[j/2-1])
			{
				SWAP(arr[j-1],arr[j/2-1]);
				j = j/2;
			}
			else 
				break;
		}
	}

	//	删除堆顶，直到堆为空
	while(len > 1)
	{
		//	交换堆顶 末尾
		SWAP(arr[0],arr[len-1]);
		len--;

		//从上往下调整
		int i = 1;
		while(i <= len)
		{
			if(i*2+1 <= len)
			{
				if(arr[i*2] > arr[i*2-1] 
					&& arr[i*2] > arr[i-1])
				{
					SWAP(arr[i*2],arr[i-1]);
					i = i*2+1;
				}
				else if(arr[i*2-1] > arr[i-1])
				{
					SWAP(arr[i*2-1],arr[i-1]);
					i = i*2;
				}
				else
					break;
			}
			else if(i*2 <= len)
			{
				if(arr[i*2-1] > arr[i-1])
				{
					SWAP(arr[i*2-1],arr[i-1]);
					i = i*2;
				}
				else
					break;
			}
			else
				break;
		}
	}
}

递归实现：

//	从top下标 到end下标 从上往下调整成堆结构
void _sort_heap_recursion(int* arr,int top,int end)
{
	if(top >= end) return;

	int max = top+1;	//	max是左右根中最大值的编号
	int l = max*2;
	int r = max*2+1;
	if(l-1 <= end && arr[l-1] > arr[max-1])
	{
		//	有左子树，且左子树大于max的值，更新max
		max = l;
	}
	if(r-1 <= end && arr[r-1] > arr[max-1])
	{
		//	有右子树，且右子树大于max的值，更新max
		max = r;
	}
	if(max-1 != top)
	{
		//	max是左右根中最大的，交换根与max
		SWAP(arr[top],arr[max-1]);
		_sort_heap_recursion(arr,max-1,end);
	}
}

//	堆排序 递归实现
void sort_heap_recursion(int* arr,int len)
{
	//	把数组调成堆结构
	for(int i=2; i<=len; i++)
	{
		int j=i;
		while(j > 1)
		{
			if(arr[j-1] > arr[j/2-1])
			{
				SWAP(arr[j-1],arr[j/2-1]);
				j = j/2;
			}
			else 
				break;
		}
	}
	
	for(int i=len-1; i>0; i--)
	{
		SWAP(arr[0],arr[i]);
		_sort_heap_recursion(arr,0,i-1);
	}
}

计数排序：

找出数据中的最大值和最小值，并创建哈希表，把数据-最小值作为数组的下标访问哈希表并标记数量，标记完后，遍历哈希表，当表中的值大于0，把下标+最小值还原数据依次放回数组中，是一种典型的以空间换时间的算法

该排序算法理论上速度非常快，它不是基于比较的算法，在一定范围内整数排序时快于任意的一种比较排序算法，但是有很大的局限性：适合排序整形数据，而且数据的范围差别不宜过大，否则会非常浪费内存反而慢于比较的排序，如果数据越平均、重复数越多，性价比越高
时间复杂度：Ο(N+k)（其中k是整数的范围）
稳定性：稳定

//	计数排序
void count_sort(TYPE* arr,size_t len)
{
	TYPE max = arr[0], min = arr[0];	
	for(int i=1; i<len; i++)
	{
		if(arr[i] > max) max = arr[i];
		if(arr[i] < min) min = arr[i];
	}
	//	哈希表
	int* tmp = calloc(4,max-min+1);
	//	标记哈希表
	for(int i=0; i<len; i++)
	{
		tmp[arr[i]-min]++;	
	}
	
	//	还原数据到arr中
	for(int i=0,j=0; i<=max-min; i++)
	{
		while(tmp[i]--)
		{
			arr[j++] = i+min;	
		}
	}
	free(tmp);
	printf("%s:\n",__func__);
	show_arr(arr,len);
}

桶排序：

根据数据的值存储到不同的桶中，然后再调用其它的排序算法，度桶中的数据进行排序，然后再从桶中依次拷贝回数组中，从而降低排序的规模以此提高排序的速度，是一种典型的以空间换时间的算法
缺点：如何分桶、桶范围多大，这些都需要对数据有一定的了解
时间复杂度：Ο(N+k)
桶排序的稳定性取决于桶内排序使用的算法

//	cnt桶数 ragne桶中数据范围
void _bucket_sort(TYPE* arr,size_t len,int cnt,TYPE range)
{
	//	申请桶内存
	//	bucket指向每个桶的开头
	//  bucket_end 指向每个桶的末尾
	TYPE* bucket[cnt], *bucket_end[cnt];
	for(int i=0; i<cnt; i++)
	{
		//	数据可能全部在一个桶中
		bucket[i] = malloc(len*sizeof(TYPE));
		//	末尾指针指向开头
		bucket_end[i] = bucket[i];
	}

	//	把所有数据 按照桶的范围放入对应桶中
	for(int i=0; i<len; i++)
	{
		for(int j=0; j<cnt; j++)
		{
			if(range*j<=arr[i] && arr[i]<range*(j+1))
			{
				*(bucket_end[j]) = arr[i];
				bucket_end[j]++;
			}
		}
	}

	for(int i=0; i<cnt; i++)
	{
		//	计算每个桶中元素数量
		int size = bucket_end[i] - bucket[i];
		//	使用其他排序算法对每个桶进行单独排序
		if(1 < size) select_sort(bucket[i],size);
		//	把桶按照先后顺序，重新放入数组中
		memcpy(arr,bucket[i],size*sizeof(TYPE));
		arr += size;
		free(bucket[i]);
	}
}

//	桶排序
void bucket_sort(TYPE* arr,size_t len)
{
	_bucket_sort(arr,len,4,25);
	printf("%s:\n",__func__);
	show_arr(arr,len);
}

基数排序：

是桶排序的具体实现，首先创建10个队列(链式队列)，然后逆序计算出数据的个、十、百…位数，然后入到对应的队列中，结束后依次从队列中出队回数组中，数据下一位继续入队，依次循环，最大值的位数就是循环次数
缺点：只适合排序正整数数据，又要准备队列
时间复杂度：Ο(N+k)
稳定性：稳定的

//	基数排序
void radix_sort(TYPE* arr,size_t len)
{
	//	创建10个队列
	ListQueue* queue[10] = {};
	for(int i=0; i<10; i++)
	{
		queue[i] = create_list_queue();	
	}

	//	计算最大值的位数
	TYPE max = arr[0];
	for(int i=1; i<len; i++)
	{
		if(arr[i] > max) max = arr[i];	
	}
	int cnt_max = 0;
	while(max) 
	{
		cnt_max++;
		max /= 10;
	}

	// i是1表示个位 2表示十位...
	for(int i=1; i<=cnt_max; i++)
	{
		int mod = pow(10,i);
		int div = mod/10;

		//	把所有数据入队
		for(int j=0; j<len; j++)
		{
			//	逆序获取每个数的每一位数
			int index = arr[j]%mod/div;
			//	入到对应下标的队列中
			push_list_queue(queue[index],arr[j]);
		}

		int k = 0;
		//	依次把队列数据出队回arr
		for(int j=0; j<10; j++)
		{
			while(!empty_list_queue(queue[j]))	
			{
				arr[k++] = front_list_queue(queue[j]);	
				pop_list_queue(queue[j]);
			}
		}
	}
	for(int i=0; i<10; i++)
	{
		destory_list_queue(queue[i]);	
	}
	printf("%s:\n",__func__);
	show_arr(arr,len);
}

排序算法性能

排序算法	平均空间复杂度	最好情况	最坏情况	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n)	O(N^2)	O(1)	稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
希尔排序	O(n log n)	O(n log^2 n)	O(n log^2 n)	O(1)	不稳定
快速排序	O(n log n)	O(n log n)	O(N^2)	O( log n)	不稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(n log n)	O(n log n)	O(1)	不稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(k)	稳定
桶排序	O(n+k)	O(n+k)	O(N^2)	O(n+k)	稳定
基数排序	O(n×k)	O(n×k)	O(n×k)	O(n+k)	稳定