排序-归并排序与计数排序

发布时间:2023年12月17日


一、归并排序

1、概念

是建立在归并操作上的一种有效,稳定的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

在这里插入图片描述

2、过程

假设前提:
左半区间 ->有序
右半区间 ->有序
怎么使左右排序呢?
当只剩下一个元素时我们可以默认其为有序的,所以我们可以利用递归将数组中的元素划分为一个,再两组两组合并,以此类推。
归并,依次对比取小的放到新到临时数组中,完成排序后再将临时数组的数据拷贝回原来的数组
过程图:
在这里插入图片描述

3、代码实现

递归:

void Print(int* arr, int n) {

	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
}
//递归


void _MergeSort(int *a,int *t,int left,int right) {
	//结束条件
	if (left >= right)
		return;

	int mid = (left + right) >> 1;//取中间数,划分区间
	//[left  mid]  [mid+1  right]
	//递归
	_MergeSort(a, t, left, mid);
	_MergeSort(a, t, mid + 1, right);
	//回归
	int begin1 = left, end1 = mid;//左区间
	int begin2 = mid + 1 , end2  = right;//右区间
	//临时数组下标->对应的是数组a的下标
	int index = left;
	//当左区间或者右区间,遍历完了就结束了
	while (begin1 <= end1 && begin2 <= end2) {
	//选择小的放进临时数组
		if (a[begin1] < a[begin2])
			t[index++] = a[begin1++];
		else
			t[index++] = a[begin2++];
	}
	//判断左右两边是否都空了,不为空将后面补上
	while (begin1 <= end1)
		t[index++] = a[begin1++];
	while (begin2 <= end2)
		t[index++] = a[begin2++];
		//最后拷贝回去
	for (int i = left; i <= right; ++i)
		a[i] = t[i];
 }
void MergeSort(int* a, int n) {
	int* t = (int*)malloc(sizeof(int) * n);
	_MergeSort(a, t, 0, n - 1);
	
	free(t);
}

int main() {
	int a[] = { 3710962385 };
	MergeSort(a, sizeof(a) / sizeof(a[0]));
	Print(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

递归图(左边,先递后归):
在这里插入图片描述

非递归:
我们通过循环来实现非递归
(1)设置一个gap来划分归并个数,先设置gap=1,这样控制第一次是两个数合并,gap再乘2,来递增,当 gap>n(数组大小)时结束
(2)在合并的过程中可能出现两种情况
a.合并过程中右边没元素
如:
在这里插入图片描述
解决办法:因为已经排好了,直接打破循环即可
b,右边有元素但是不够
如:
在这里插入图片描述
解决办法:进行纠正,将右端的下标改为 n-1(数组大小-1)

代码实现:

//非递归

void MergeSortNonR(int* a, int* t,int n) {
	int gap= 1;//划分一次归并多少个元素
	//结束条件
	while (gap<n) {
		for (int i = 0; i < n; i += 2*gap) {
		//通过gap划分区间
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + gap * 2 - 1;
			//情况a,此时直接打破即可
			if (begin2 >= n)
				break;
				//情况b,进行纠正
			if (end2 >= n)
				end2 = n - 1;
 
			int index = i;//从控制的区间最小的位置开始
			//下面过程与递归过程一样
			while (begin1 <= end1 && begin2 <= end2) {
				if (a[begin1] < a[begin2])
					t[index++] = a[begin1++];
				else
					t[index++] = a[begin2++];
			}
			while (begin1 <= end1)
				t[index++] = a[begin1++];
			while (begin2 <= end2)
				t[index++] = a[begin2++];
			for (int j = i; j <= end2; j++)
				a[j] = t[j];
		}
		gap *= 2;//每次加倍
	}
}



void MergeSort(int* a, int n) {
	int* t = (int*)malloc(sizeof(int) * n);
	MergeSortNonR(a, t, n);
	free(t);
}

int main() {
	int a[] = { 6,3,7,1,9,5,2,8,0,4 };
	MergeSort(a, sizeof(a) / sizeof(a[0]));
	Print(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

4、复杂度

时间复杂度:
(1)循环部分:N
(2)递归部分:因为每次都减半所以就是logN(以2为底)
所以时间复杂度为:O(N*logN)
空间复杂度:
因为要重新开辟一个数组,所以空间复杂度为O(N)

5、稳定性

在归并过程中相同的元素的顺序不会发生改变,所以是稳定的

二、 计数排序

1、思路

通过映射统计每个数出现的次数,再使用次数排序
如:
在这里插入图片描述
上述是以最大数去创建空间
但是如果遇到一个很大的数的话就需要我们创建空间时就会很浪费
如:
在这里插入图片描述
解决:找到范围,使用范围+1去创建临时空间

2、代码实现

//计数排序
void  CountSort(int* a, int n) {
	int max = a[0];
	int min = a[0];
	//求出数组的范围
	for (int i = 0; i < n; i++) {
		if (max < a[i])
			max = a[i];
		if (min > a[i])
			min = a[i];
	}
	int  t = max - min+1;
	//临时空间
	int* p = (int*)calloc(t,sizeof(int));
	//统计个数
	for (int j = 0; j < n; j++) {
		//a[j]-min当下标,我们下次直接加回min即可
		p[a[j] - min]++;
	}
	int i = 0;
	//按顺序拷贝回原来的数组
	for (int j = 0; j < t; j++) {
		
		while (p[j]) {
			a[i] = j + min;
			i++;
			p[j]--;
		}
	}
	free(p);
	p = NULL;
}

3、复杂度:

空间复杂度:因为要创建临时的空间,所以复杂度为O(N);
时间复杂度:O(N+t)

4、稳定性

在统计和重新排序过程中相同元素可能位置发生交换,所以为不稳定

以上就是我的分享了,如果有什么错误,欢迎在评论区留言。
最后,谢谢大家的观看!

文章来源:https://blog.csdn.net/2302_79539362/article/details/134986382
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。