合并排序

最新推荐文章于 2022-11-27 14:28:13 发布

原创最新推荐文章于 2022-11-27 14:28:13 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

C++编程实践专栏收录该内容

36 篇文章

订阅专栏

本文详细介绍了如何使用C++实现合并排序算法，并提供了相关的代码实现。包括元素类定义、数据列表类、链接队列类及合并排序类的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

今天，我们的目标就是一起用C++实现合并排序，具体代码如下。

Data.h具体内容：

template<typename Type> class Element{
public:
	Type GetKey(){
		return key;
	}

	void SetKey(Type item){
		key = item;
	}

public:
	Element<Type>& operator =(Element<Type> copy){
		key = copy.key;
		return *this;
	}

	bool operator ==(Element<Type> item){
		return this->key == item.key;
	}

	bool operator !=(Element<Type> item){
		return this->key != item.key;
	}

	bool operator <(Element<Type> item){
		return this->key < item.key;
	}

	bool operator >(Element<Type> item){
		return this->key > item.key;
	}

	bool operator >=(Element<Type> item){
		return this->key >= item.key;
	}

	bool operator <=(Element<Type> item){
		return this->key <= item.key;
	}


private:
	Type key;
};

template<typename Type> class Sort;
template<typename Type> class DataList{
public:
	friend class Sort < Type > ;
	DataList(int size = m_nDefaultSize) : m_nMaxSize(size), m_ncurrentsize(0){
		m_pvector = new Element<Type>[size];
	}

	DataList(Type *data, int size);

	bool Insert(Type item);
	~DataList(){
		delete[] m_pvector;
	}

	int Size(){
		return this->m_ncurrentsize;
	}
	void Swap(Element<Type> &left, Element<Type> &right){
		Element<Type> temp = left;
		left = right;
		right = temp;
	}

	void Print();
private:
	static const int m_nDefaultSize = 10;
	Element<Type> *m_pvector;
	const int m_nMaxSize;
	int m_ncurrentsize;
};

template<typename Type> DataList<Type>::DataList(Type *data, int size)
	: m_nMaxSize(size > m_nDefaultSize ? size : m_nDefaultSize), m_ncurrentsize(0){
	this->m_pvector = new Element<Type>[size];
	for (int i = 0; i < size; i++){
		this->m_pvector[i].SetKey(data[i]);
	}
	this->m_ncurrentsize += size;

}

template<typename Type> bool DataList<Type>::Insert(Type item){
	if (this->m_ncurrentsize == this->m_nMaxSize){
		cerr << "The list is full!" << endl;
		return 0;
	}
	this->m_pvector[this->m_ncurrentsize++].SetKey(item);
}

template<typename Type> void DataList<Type>::Print(){
	cout << "The list is:";
	for (int i = 0; i < this->m_ncurrentsize; i++){
		cout << " " << this->m_pvector[i].GetKey();
	}
}

LinkQueue.h具体内容：

#include "QueueNode.h"

template<typename Type> class LinkQueue{
public:
	LinkQueue() :m_prear(NULL), m_pfront(NULL){}
	~LinkQueue(){
		MakeEmpty();
	}
	void Append(const Type item);
	Type Delete();
	Type GetFront();
	void MakeEmpty();
	bool IsEmpty() const{
		return m_pfront == NULL;
	}
	void Print();

private:
	QueueNode<Type> *m_prear, *m_pfront;
};

template<typename Type> void LinkQueue<Type>::MakeEmpty(){
	QueueNode<Type> *pdel;
	while (m_pfront){
		pdel = m_pfront;
		m_pfront = m_pfront->m_pnext;
		delete pdel;
	}
}

template<typename Type> void LinkQueue<Type>::Append(const Type item){
	if (m_pfront == NULL){
		m_pfront = m_prear = new QueueNode<Type>(item);
	}
	else{
		m_prear = m_prear->m_pnext = new QueueNode<Type>(item);
	}
}

template<typename Type> Type LinkQueue<Type>::Delete(){
	if (IsEmpty()){
		cout << "There is no element!" << endl;
		exit(1);
	}
	QueueNode<Type> *pdel = m_pfront;
	Type temp = m_pfront->m_data;
	m_pfront = m_pfront->m_pnext;
	delete pdel;
	return temp;
}

template<typename Type> Type LinkQueue<Type>::GetFront(){
	if (IsEmpty()){
		cout << "There is no element!" << endl;
		exit(1);
	}
	return m_pfront->m_data;
}

template<typename Type> void LinkQueue<Type>::Print(){
	QueueNode<Type> *pmove = m_pfront;
	cout << "front";
	while (pmove){
		cout << "--->" << pmove->m_data;
		pmove = pmove->m_pnext;
	}
	cout << "--->rear" << endl << endl << endl;
}

QueueNode.h具体内容：

template<typename Type> class LinkQueue;
template<typename Type>
class QueueNode
{
private:
	friend class LinkQueue < Type > ;
	QueueNode(const Type item, QueueNode<Type> *next = NULL)
		:m_data(item), m_pnext(next){}
private:
	Type m_data;
	QueueNode<Type> *m_pnext;
};

Sort.h具体内容如下：

#include "Data.h"
#include "LinkQueue.h"

template<typename Type> class Sort{
public:
	void MergeSort(DataList<Type> &list);
private:
	void Merge(DataList<Type> &list, DataList<Type> &mergedlist, const int len);
	void MergeDouble(DataList<Type> &list, DataList<Type> &mergedlist, const int start, const int part, const int end);
};

template<typename Type>
void Sort<Type>::MergeDouble(DataList<Type> &list, DataList<Type> &mergedlist, const int start, const int part, const int end){
	int i = start, j = part + 1, k = start;
	while (i <= part && j <= end){
		if (list.m_pvector[i] <= list.m_pvector[j]){
			mergedlist.m_pvector[k++] = list.m_pvector[i++];
		}
		else {
			mergedlist.m_pvector[k++] = list.m_pvector[j++];
		}
	}
	if (i <= part){
		for (int m = i; m <= part && k <= end;){
			mergedlist.m_pvector[k++] = list.m_pvector[m++];
		}
	}
	else {
		for (int m = j; m <= end && k <= end; m++){
			mergedlist.m_pvector[k++] = list.m_pvector[m];
		}
	}
}
template<typename Type>
void Sort<Type>::Merge(DataList<Type> &list, DataList<Type> &mergedlist, const int len)
{
	int n = 0;
	while (n + 2 * len < list.m_ncurrentsize){
		MergeDouble(list, mergedlist, n, n + len - 1, n + 2 * len - 1);
		n += 2 * len;
	}
	if (n + len < list.m_ncurrentsize){
		MergeDouble(list, mergedlist, n, n + len - 1, list.m_ncurrentsize - 1);
	}
	else {
		for (int i = n; i < list.m_ncurrentsize; i++){
			mergedlist.m_pvector[i] = list.m_pvector[i];
		}
	}
}

template<typename Type>
void Sort<Type>::MergeSort(DataList<Type> &list)
{
	DataList<Type> temp(list.m_nMaxSize);
	temp.m_ncurrentsize = list.m_ncurrentsize;
	int len = 1;
	while (len < list.m_ncurrentsize){
		Merge(list, temp, len);
		len *= 2;
		Merge(temp, list, len);
		len *= 2;
	}
}

main.cpp的内容如下：

#include <iostream>
using namespace std;
#include "Sort.h"
int main()
{
	int init[15] = { 1, 3, 5, 7, 4, 2, 8, 0, 6, 9, 29, 13, 25, 11, 32 };
	DataList<int> data(init, 15);
	Sort<int> sort;
	data.Print();
	cout << endl << endl << endl;	
	sort.MergeSort(data);
	data.Print();
	cin.get();
	return 0;
}

运行效果如图1所示：