数据结构与算法——希尔排序与归并排序

希尔排序

希尔排序（shell sort），对插入算法进行了有效的改进，是一种递减增量的排序算法。希尔排序算法是不稳定的，他是是基于插入排序提出改进方法的： 插入排序在对已经排好序的数据操作时，效率高，即可以达到线性排序的效率 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

演示：

描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

实现：

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

void ShellSort(int arr[],int n) 
{
	for (size_t gap = n/2; gap > 0; gap /= 2)
	{
		for (size_t i = gap; i < n; i++)
		{
			int j = i;
			while(j-gap >= 0 && arr[j-gap] > arr[j])
			{
				int temp = arr[j-gap];
				arr[j-gap] = arr[j];
				arr[j] = temp;
				j -= gap;
			}
		}
	}
}

int main()
{
	int arr[10] = { 1,6,3,7,85,23,56,94,0,345 };
	ShellSort(arr, 10);


	for (int i : arr)
	{
		cout << "  " << i;
	}

	cout << endl;

	return system("pause");

}

复杂度：

• 时间复杂度平均O(n^1.3),最坏O(n^2),最好O(n)
• 空间复杂度O(1)
• 不稳定

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。 

演示：

描述：

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

实现：

1. 基于递归的归并排序（自顶向下的归并排序）

/*
TODO优化:
1. 在小数组的时候才用插入排序
·用不同的方法处理小规模问题能改进大多数递归算法的性能，因为递归会使小规模问题中方法调用太过频繁，
·所以改进对它们的处理方法就能改进整个算法。因为插入排序非常简单， 因此一般来说在小数组上比归并排序更快。 这种优化能使归并排序的运行时间缩短10%到15%。
2. 避免临时数组temp的分配与释放
*/

void Merge(int arr[],int low,int mid,int high) 
{
	int i = low;//1区最小值
	int j = mid + 1;//2区最小值
	int k = 0;

	int* temp = new int[high - low + 1];//临时存储区

	while (i <= mid && j <= high) 
	{
		if (arr[i] > arr[j])
		{
			temp[k++] = arr[j++];
		}
		else
		{
			temp[k++] = arr[i++];
		}
	}

	while (i <= mid)
		temp[k++] = arr[i++];

	while (j <= high)
		temp[k++] = arr[j++];

	for (i = low,k = 0; i <= high; i++,k++) 
	{
		arr[i] = temp[k];
	}

	delete[] temp;


}

void MergeSort(int arr[], int low,int high) 
{
	/*
	*优化1：
	*if(high - low <= 10) { // 数组长度小于10的时候
    *  InsertSort(int arr[], int low,int high) // 切换到插入排序
    *  return;
	*}
	*/
	if (low >= high) return;
	
	
	int mid = low + (high - low) / 2;

	MergeSort(arr,low,mid);
	MergeSort(arr,mid+1,high);

	if (arr[mid] <= arr[mid + 1]) return; // 避免不必要的合并

	Merge(arr,low,mid,high);
}

2. 基于循环的归并排序（自底向上）

void Merge(int arr[],int low,int mid,int high) 
{
	int i = low;//1区最小值
	int j = mid + 1;//2区最小值
	int k = 0;

	int* temp = new int[high - low + 1];//临时存储区

	while (i <= mid && j <= high) 
	{
		if (arr[i] > arr[j])
		{
			temp[k++] = arr[j++];
		}
		else
		{
			temp[k++] = arr[i++];
		}
	}

	while (i <= mid)
		temp[k++] = arr[i++];

	while (j <= high)
		temp[k++] = arr[j++];

	for (i = low,k = 0; i <= high; i++,k++) 
	{
		arr[i] = temp[k];
	}

	delete[] temp;


}


void MergeSort2(int arr[], int n) 
{
	int mid = 0;
	int high = 0;
    /*
    * 原始数据{1，3，2，7，4，9，0,5}
    * i=1，表示左右两边各一个数据，如：[1,3],[2,7],[4,9]...
    * i=2，表示左右两边各二个数据，如：[1 3,2 7],[4 9,0 5]... 
    */
	for (int i = 1; i < n; i *= 2) 
	{
        /*
        *对照上述的描述，理解 j=j+2*i的增长;
        */
		for (int j = 0; j + i < n; j += 2 * i) 
		{
			mid = i + j - 1;//对照上述描述，i代表单区的数据量
			high = j + 2 * i - 1;//同上，两区的数据量 - 1

			if (high > n - 1) high = n - 1;//最后对尾部的处理，防止越界
			Merge(arr,j,mid,high);//合并
		}
	}
}

复杂度：

• 时间复杂度是 O（nlogn）
• 空间复杂度 O(n)
• 稳定排序算法

 

 

以上参考：

• 算法 第四版
• https://www.cnblogs.com/onepixel/articles/7674659.html
• https://zhuanlan.zhihu.com/p/74820690