排序 - 堆排序、快速排序、基数排序（静态链表）（C++）

前言：

在此之前，我分别写了堆排、快排、基数排序三篇文章，现在来进行一下总结，大家如果看过这三篇文章，会发现其中很多成员函数一模一样，嘿嘿嘿，说道这里，大家一定有一种能不能进行代码重用呢？答案当然是：可以啦！

所以，我们将上述三个独立的算法整合到一起，命名为Sort类，其中的成员函数和成员变量都没有发生改变，只是进行了3次Ctrl+C和3次Ctrl+V，然后对main（）函数进行了改动，然后就没有然后了，大功告成。

完整代码如下：

//#pragma once

#include 
using namespace std;

const int Cutoff = 28;  //阈值，当子序列元素个数小于Cutoff时，采用简单排序(在快排中)
const int RADIX = 10;  //进制数
const int MaxDigit = 4;  //单个元素所具有的的最大位数

//桶元素节点
struct Node
{
	int key;  //待排数据
	struct Node* next;  //指向下一个桶节点的指针
};
//桶头节点
struct HeadNode
{
	struct Node *head, *tail;
};
typedef struct HeadNode Bucket[RADIX];

template 
class Sort
{
private:
	Bucket B;  //桶
	T * A;  //存放堆元素的数组
	int N;  //堆中的元素个数

public:
	Sort(int InputSize);  //构造函数
	~Sort() { delete[] A; cout << "析构函数执行成功" << endl; }  //析构函数

	//堆排序
	void HeapSort();  //堆排序
	void PercDown(int p, int N);  //将N个元素的数组中以A[p]为根的子堆调整为最大堆

	//快速排序
	void QuickSort(int Left, int Right);  //递归进行快排
	T Median3(int Left, int Right);  //选主原（轴值）- 取头、中、尾的中位数
	void InsertSort(T* B, int Nb);  //当子序列元素个数小于阈值时调用插入排序

	//基数排序
	int GetDigit(int X, int D);  //获得当前元素的当前位
	void LSD_RadixSort();  //基于次位优先的基数排序

	void Print();  //输出堆中的元素
	friend void Swap(T* a, T* b);  //交换堆顶和堆末尾的元素 - 友元函数类似于全局函数
};

//Sort类的实现
//Sort(int InputSize) - 构造函数
template  Sort::Sort(int InputSize)
{
	this->N = InputSize;  //this指当前对象
	this->A = new T[N];  //为数组分配空间
	for (int i = 0; i < N; ++i)
		cin >> A[i];
}

//Swap(T,T) - 交换两个元素
template  void Swap(T* a, T* b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

//Print()
template  void Sort::Print()
{
	for (int i = 0; i < N; ++i)
		cout << A[i] << " ";
	cout << endl;
}

//堆排序
template  void Sort::HeapSort()
{
	int i;
	//for循环中的语句是针对从下标为0的位置开始存放的情况 
	//该最大堆的建立是从完全二叉树的倒数第二层开始的 
	for (i = N / 2 - 1; i >= 0; i--)   //建立最大堆
		PercDown(i, N);
	for (i = N - 1; i > 0; i--)
	{
		//删除最大堆顶
		Swap(&A[0], &A[i]);  //将堆顶元素放到堆末尾，并且堆的规模减1 
		PercDown(0, i);  //将规模减小的堆再一次调整为最大堆 
	}
}

//将N个元素的数组中以A[p]为根的子堆调整为最大堆
//最大堆的建立不是一步到位的
//先调整其左、右子树，一步一步上滤
template  void Sort::PercDown(int p, int N)
{
	int parent, child;
	int x;

	x = A[p];      //取出根节点存放的值
	for (parent = p; (parent * 2 + 1) < N; parent = child)
	{
		child = parent * 2 + 1;
		if ((child != N - 1) && (A[child] < A[child + 1]))
			child++;   //child指向左右子节点的最大值
		if (x > A[child]) break;   //找到了合适的位置
		else        //下滤x
			A[parent] = A[child];
	}
	A[parent] = x;
}

//插入排序
template  void Sort::InsertSort(T* B, int Nb)
{
	int tmp, p, i;
	for (p = 1; p < Nb; ++p)  //总共摸取Nb-1张牌
	{
		tmp = B[p];  //当前摸到手中的一张牌
		for (i = p; i > 0 && A[i - 1] > tmp; i--)  //i很多情况下都是用来控制循环次数的
		{
			A[i] = A[i - 1];
		}
		A[i] = tmp;  //新牌归位
	}
}

//选轴值pivot
template   T Sort::Median3(int Left, int Right)
{
	int Center = (Left + Right) / 2;

	if (A[Left] > A[Center])
		Swap(&A[Left], &A[Center]);
	if (A[Left] > A[Right])
		Swap(&A[Left], &A[Right]);
	if (A[Center] > A[Right])
		Swap(&A[Center], &A[Right]);
	//此时A[Left] <= A[Center] <= A[Right],为了接下来的分割过程，将轴值藏到右边
	//将轴值藏到子序列的右端只是为了不影响分割过程
	//分割时只需考虑A[Left+1] - A[Right-2]的区间
	Swap(&A[Center], &A[Right - 1]);
	//返回轴值
	return A[Right - 1];
}

//递归分割
template  void Sort::QuickSort(int Left, int Right)
{
	int Pivot, Low, High;  //基准、左、右指针

	if (Cutoff < Right - Left)  //如果序列元素充分多，则进入快排
	{
		Pivot = Median3(Left, Right);
		Low = Left;
		High = Right - 1;

		//分割过程
		while (true)
		{
			while (A[++Low] < Pivot);
			while (A[--High] > Pivot);
			if (Low < High)
				Swap(&A[Low], &A[High]);
			else
				break;
		}
		//将当前子序列的轴值一次性的放到他最终所在的位置上 - Low
		Swap(&A[Low], &A[Right - 1]);
		//当前子序列分割完成，递归进入更小一层子序列的分割
		QuickSort(Left, Low - 1);  //递归解决左边子序列
		QuickSort(Low + 1, Right);  //递归解决右边子序列
	}
	else
		InsertSort(A + Left, Right - Left + 1);  //当子序列足够短时，采用插入排序
}

//获得当前元素的当前位
template  int Sort::GetDigit(int X, int D)
{
	int d, i;
	for (i = 1; i <= D; ++i)
	{
		d = X % RADIX;  //求余
		X /= RADIX;  //缩小RADIX倍
	}

	return d;
}

//基于次位优先的基数排序
template  void Sort::LSD_RadixSort()
{
	int D, Di, i;  //D、Di - 当前位、i - 计数变量
	struct Node *tmp, *p, *List = NULL;  //初始链表表头List，采用头插法

										 //初始化每个桶为空链表
	for (i = 0; i < RADIX; ++i)
		B[i].head = B[i].tail = NULL;

	//List就是用来存储数组元素的链表
	//List采用头插法生成链表
	for (i = 0; i < N; ++i)
	{
		tmp = new Node;
		tmp->key = A[i];
		tmp->next = List;
		List = tmp;
	}

	//下面次用次位优先的方法对数据进行排序
	for (D = 1; D <= MaxDigit; ++D)
	{
		//下面是分配的过程,用p来暂时接管这趟排序用到的List链表
		p = List;
		while (p)  //当链表不为空
		{
			Di = GetDigit(p->key, D);  //获得当前元素的当前位
									   //从List中摘除，从list链表头拿走一个节点 
									   //这里的摘除只是从p链表中摘除，但是最初的List链表一直到在
									   //因为List要经历一次又一次的扫描，直到最高位 
			tmp = p;
			p = p->next;
			//插入B[Di]号桶尾,这里又采用尾插法
			tmp->next = NULL;
			if (B[Di].head == NULL)  //无头节点、链表为空
				B[Di].head = B[Di].tail = tmp;
			else
			{
				B[Di].tail->next = tmp;  //原先的尾节点连接上新加入进来的节点
				B[Di].tail = tmp;  //更新尾节点
			}
		}
		//一趟排序完成，下面扫描桶中的元素生成新的List链表
		List = NULL;
		for (Di = RADIX - 1; Di >= 0; --Di)
		{
			//这里建立的List链表也是采用头插法，倒着插
			if (B[Di].head)  //如果当前桶不为空
			{
				//将整桶插入List表头
				B[Di].tail->next = List;
				List = B[Di].head;  //更新表头
				B[Di].head = B[Di].tail = NULL;  //清空桶
			}
		}
	}

	//将List倒入A[]并释放空间
	for (i = 0; i < N; ++i)
	{
		tmp = List;
		List = List->next;
		A[i] = tmp->key;
		delete tmp;  //释放空间
		tmp = NULL;  //避免野指针
	}
}

int main()
{
	int QN, RN, HN;

	//快速排序
	cin >> QN;
	Sort Q(QN);
	Q.QuickSort(0, QN - 1);
	cout << "快速排序：";
	Q.Print();

	//基数排序
	cin >> RN;
	Sort R(RN);
	R.LSD_RadixSort();
	cout << "基数排序：";
	R.Print();

    //堆排
	cin >> HN;
	Sort H(HN);
	H.HeapSort();
	cout << "堆排序：";
	H.Print();

	return 0;
}

运行结果：

后记：

最近在看一本书，是红衣教主周鸿祎写的《我的互联网方法论》，他讲到了互联网的本质——Free，没错，就是免费，Internet这条信息高速公路不仅仅需要哪些专业人士去建造，而且需要我们每一个人来贡献出一些东西，我们需要站在巨人的肩膀上去眺望未来，编程也是这样，不要刀耕火种，我们需要交流，相互交流，这也是我为什么要花我的一部分时间来写博客的原因，我所写的这些东西也许都是上个世纪的产物了，很多人都在写，但是我希望我们每个人都来写，因为分享知识从来都是一件令人快乐的事。