全网首发！使用链接信息表改进的归并排序

前言

该算法为本人在算法设计与分析课程中的作业。此算法新颖，当时网上找不到任何可参考的代码，现在我发这篇文章来填补这一空白。

传统的归并排序存在的问题

1.递归层次太深

在传统归并排序算法的执行过程中，当集合仅含有两个元素时，仍要进一步做递归调用，直至每个集合仅含有一个元素时才退出递归调用。 在集合含有仅相当少的元素时，较深层次的递归调用使得时间过多地消耗在处理递归上。

2.频繁移动

元素在数组A和辅助数组B之间的频繁移动，每次归并，都要首先将A中的元素移到B中，再由B复制到A的对应位置上，极大影响效率。

改进措施

1.针对递归层次问题

采用能在小规模集合上有效工作的其它算法，直接对小规模集合处理。 如插入排序算法。

2.针对元素频繁移动问题

采用一个称为链接信息数组LINK（1：n）的数据结构， 记录归并过程中A中的元素相对于其排序后在分类表中位置 坐标的链接关系。 LINK(i)取值于[1，n]，是指向A的元素的指针：在分类表中它指向下一个元素在A中的位置坐标。

伪代码

源代码

复制代码之前请先点个赞，谢谢。

//基于链接表的改进后的归并排序
//姓名： 23-064181-FZX 
//学号： 20181003670

#include <iostream>
#include <ctime>
using namespace std;

//处理前数组,处理后数组和链接表
int* a;
int* b;
int* link;

int insertionSort(int start, int end);
int merge1(int q, int r);
int mergeSort1(int low, int high);

int main()
{
	int length = 0;
	int begin = 0;

	do
	{
		cout << "输入随机生成的数据个数（输入-1结束程序）：";
		cin >> length;
		if (length == -1) break;
		

		a = new int[length];//待排序数组
		b = new int[length];//存放排好序的数组
		link = new int[length];//链接表

		//用随机数填充待排序数组
		srand((unsigned)time(nullptr));
		cout << endl << "排序前: " << endl;
		for (int i = 0; i < length; ++i)
		{
			a[i] = rand()%100;
			cout << a[i] << "\t" << ends;//输出未排序的数组
			link[i] = -1;//这里用-1初始化链接表，使得待排序数组下标可被全部利用
		}
		cout << endl;

		//基于链接表的归并排序
		begin = mergeSort1(0, length - 1);

		//将原数组按link的次序放入数组b中，同时输出
		int i = 0;
		cout << endl << "排序后: " << endl;
		for (int j = begin; j !=-1; j=link[j])
		{
			b[i++] = a[j];
			cout << a[j] <<"\t"<<ends;
		}
		cout << endl << endl;

		delete[]a;
		delete[]b;
		delete[]link;

	} while (1);

	return 0;
}


/*基于链接信息数组的插入排序*/
int insertionSort(int start, int end)//这里是难点
{
	int head = start;
	for (int i = start + 1; i <= end; i++) //i在目标数组中顺序遍历
	{
		if (a[i] <= a[head]) //如果当前位置的值小于head位置的值
		{
			link[i] = head;//将head连到当前位置的后面
			head = i;//将当前位置作为新的head
		}
		else //如果当前位置的值大于head位置的值
		{
			int j = head;//从head开始找
			while ((link[j] != -1) && (a[link[j]] <= a[i]))
				j = link[j];//从head顺着link往后找，直到找到未连接的或者找到比当前值小的最大值为止

			if (link[j] == -1)//如果找到了未连接的
				link[j] = i;

			else //如果找到的是比当前值小的最大值
			{//则将当前值插到这个值后面

				link[i] = link[j];//相当于 curr->next = p->next;
				link[j] = i;	  //相当于    p->next = curr;
			}
		}
	}
	return head;
}

//合并
int merge1(int q, int r)
{
	int head;

	//找到两个开头中，最小的作为新开头
	if (a[q] > a[r])
	{
		head = r;
		r = link[r];
	}
	else
	{
		head = q;
		q = link[q];
	}

	//这后面的和伪代码一样
	int k = head;
	int i = q, j = r;
	while (i != -1 && j != -1)
	{
		if (a[i] < a[j])
		{
			link[k] = i;
			k = i;
			i = link[i];
		}
		else
		{
			link[k] = j;
			k = j;
			j = link[j];
		}
	}
	if (i == -1)
	{
		link[k] = j;
	}
	else
	{
		link[k] = i;
	}
	return head;
}

int mergeSort1(int low, int high)
{
	if (high - low + 1 < 16)
	{
		int p = insertionSort(low, high);
		return p;
	}
	else
	{
		int mid = (low + high) / 2;
		int q = mergeSort1(low, mid);
		int r = mergeSort1(mid + 1, high);
		return merge1(q, r);
	}
}

测试

可见改进使算法大幅度优化。