DS内排—2-路归并排序

题目描述

输入一组字符串,用2-路归并排序按字典顺序进行降序排序。

输入

测试次数t

每组测试数据:数据个数n,后跟n个字符串,字符串不含空格。

输出

对每组测试数据,输出2-路归并排序的每一趟排序结果。每组测试数据的输出之间有1空行。

输入样例1

2
6 shenzhen beijing guangzhou futian nanshan baoan
10 apple pear peach grape cherry dew fig haw lemon marc

输出样例1

shenzhen beijing guangzhou futian nanshan baoan
shenzhen guangzhou futian beijing nanshan baoan
shenzhen nanshan guangzhou futian beijing baoan

pear apple peach grape dew cherry haw fig marc lemon
pear peach grape apple haw fig dew cherry marc lemon
pear peach haw grape fig dew cherry apple marc lemon
pear peach marc lemon haw grape fig dew cherry apple

思路总结:

这里使用了vector容器,将字符串数组存放到容器中,然后使用sort函数进行字典序排序。接着设一个times变量,初始值是2,两两合并,合并后一个数组的大小分别是1,2,4,8;若剩下的不够长就剩下的组成一个组,不操作 。当times/2比n大跳出循环。

代码

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

int t;

class MergeSort {
private:
	int n;
	int low, high;
	int times = 2;
	vector<string> str;
	void Merge_Sort(int low, int high);
	void Merge(int low, int high);
public:
	
	void main();
};

bool Comp(const string& a, const string& b)
{
	return a > b;
}

void MergeSort::Merge(int low, int high)
{
	vector<string> tmp;
	for (int i = low; i <= high; i++)
	{
		tmp.push_back(str[i]);
	}
	sort(tmp.begin(), tmp.end(), Comp);
	int k = 0;
	for (int i = low; i <= high; i++)
	{
		str[i] = tmp[k++];
	}
}

void MergeSort::Merge_Sort(int low, int high)
{
	while (1)
	{
		if (times / 2 > n)break;
		if (times > n && times / 2 <= n)
		{
			Merge(0, n - 1);
		}
		if (times < n)
		{
			for (int i = 0; i < n; i += times)
			{
				if ((i + times - 1) < n)
					Merge(i, i + times - 1);
				else
					Merge(i, high);
			}
		}
		for (int i = 0; i < n; i++)
		{
			cout << str[i];
			if (i < n - 1)cout << ' ';
		}
		cout << endl;
		times *= 2;
	}

}

void MergeSort::main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		string tmpstr;
		cin >> tmpstr;
		str.push_back(tmpstr);
	}
	
	Merge_Sort(0, n - 1);

}

int main()
{
	cin >> t;
	while (t--)
	{
		MergeSort ms;
		ms.main();
		if (t)cout << endl;
	}
}
### 数据结构中的堆序 #### 堆序概述 堆序是一种基于二叉堆数据结构实现的排序算法。该算法通过构建和调整堆来完成序操作,时间复杂度为 O(n log n)[^2]。 #### 二叉堆特性 二叉堆是一个近似完全二叉树的数据结构,在逻辑上可以分为两种形式:最大堆(Max Heap)和最小堆(Min Heap)。对于最大堆而言,父节点的关键字总是大于等于子节点关键字;而对于最小堆,则相反。这种性质使得堆顶元素始终是整个集合的最大值或最小值[^3]。 #### 构建最大堆/最小堆 为了执行堆序,首先要将待序序列构建成一个初始堆。通常情况下会选择构建最大堆以便升序列最终结果。具体过程如下: 1. 将给定数组视为一棵完整的二叉树; 2. 自底向上遍历非叶子节点并调用 `heapify` 函数修复当前子树使其满足堆属性; 3. 完成上述步骤后即得到所需类型的初始堆。 ```python def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i],arr[largest] = arr[largest],arr[i] heapify(arr, n, largest) def build_heap(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) ``` #### 执行堆序 一旦建立了合适的堆之后就可以开始正式序了。每次取出堆顶元素作为已序部分的第一个元素,并将其与最后一个未序位置交换,随后减少堆大小并对新形成的根节点再次应用 `heapify` 来维持剩余部分仍保持有效堆形态直到全部元素都被处理完毕为止。 ```python def heap_sort(arr): build_heap(arr) for i in range(len(arr)-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) ``` #### 特点总结 - 时间复杂度稳定为 O(n log n),适用于大规模数据集。 - 是一种原地排序算法,只需要占用少量额外空间。 - 不稳定性意味着相同键值记录之间的相对顺序可能会改变。 - 对于内存敏感的应用场景特别有用,因为不需要大量辅助存储资源即可工作良好[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值