数据结构——计数与归并非递归

---

前言

重要的事说三遍！
学习！学习！学习！
努力!努力!努力！

---

一、归并的非递归实现

代码实现：

void MergeSortNonR(int* a, int n)
{
    
    
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
    
    
		perror("malloc fail");
		return;
	}

	int gap = 1;
	while (gap < n)
	{
    
    
		for (int i = 0; i < n; i += 2 * gap)
		{
    
    
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			// [begin1,end1] [begin2,end2] 归并
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
    
    
				if (a[begin1] < a[begin2])
				{
    
    
					tmp[index++] = a[begin1++];
				}
				else
				{
    
    
					tmp[index++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
    
    
				tmp[index++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
    
    
				tmp[index++] = a[begin2++];
			}

			// 拷贝回原数组
			memcpy(a + i, tmp + i, (2 * gap) * sizeof(int));
		}
		gap *= 2;
	}

	free(tmp);
}

二、计数排序

思想：
计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。

代码实现：

void CountSort(int* a, int n)
{
    
    
	int min = a[0], max = a[0];
	for (size_t i = 0; i < n; i++)
	{
    
    
		if (a[i] < min)
			min = a[i];

		if (a[i] > max)
			max = a[i];
	}

	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	
	if (count == NULL)
	{
    
    
		perror("malloc fail");
		return;
	}
	memset(count, 0, sizeof(int) * range);

	// 统计数据出现次数
	for (int i = 0; i < n; i++)
	{
    
    
		count[a[i] - min]++;
	}

	// 排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
    
    
		while (count[i]--)
		{
    
    
			a[j++] = i + min;
		}
	}
}

计数排序的特性总结：

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定

三、序算法复杂度及稳定性分析

扫描二维码关注公众号，回复： 16978313 查看本文章

---

总结

重要的事说三遍！
成功！成功！成功！
加油吧！从现在开始~