希尔排序
希尔排序(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)
- 稳定排序算法
以上参考: