排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
最常用的排序算法有7种
插入排序
基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。类似于玩扑克
直接插入排序
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移
先对单趟排序进行编写
假设把x插入到一个有序数组中，排成升序
void Insert_sort1(int* arr,int n)
{
int x = 10;
int end = n-1;
while(end >= 0)
{
if(arr[end] > x)
{
arr[end+1] = arr[end];
end--;
}
else
break;
}
arr[end+1] = x;
}
排序过程
对单趟排序分析可知：
当数组 arr[i] 的元素大于x数组就会从 i 位置往后挪，当数组 arr[i] 的数小于X则退出循环，并把x值放在 i 的下一位
所以数组必须是有序的，只要数组的元素小于x就直接退出，否则就会往后移且继续遍历
根据单趟排序来编写多趟排序
void Insert_sort(int* arr, int n)
{
assert(arr);
int i;
for (i = 0; i < n - 1; i++)
{
int end = i;
int x = arr[end + 1];
while (end >= 0)
{
if (arr[end] < x)
{
arr[end + 1] = arr[end];
end--;
}
else
break;
}
arr[end + 1] = x;
}
}
排序过程
相对于单趟排序，多趟排序就是从第一个数开始排序，每躺的数比前一次多一个，这样每趟开始插入比较时的前面就是有序的，直到把数组遍历完，执行的趟数就是总数个数-1，因为要留出最后X的位置防止数组越界
直接插入排序的特性总结：
- 元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)，它是一种稳定的排序算法
- 稳定性：稳定
希尔排序
希尔排序是在直接插入排序大的基础上更改的又称缩小增量法排序法的基本思想是：
先选定一个整数，把待排序文件中所有记录分成个组，所有距离为相同的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
举例说明：距离为3时编写
void ShellSort1(int* arr,int n)
{
int gap = 3;
int i,j;
for(j = 0;j<gap;j++)
{
for(i = j;i < n-gap;i+=gap)
{ //同直插一样，循环结束是总大小-gap，直插的gap是1，这里是3
int end = i;
int x = end+gap;
while(end >= 0)
{
if(arr[end] > arr[x])
{
arr[end+gap] = arr[end];
end-=gap;
}
else
break;
}
arr[end+gap] = x;
}
}
//Insert_sort(arr,n);
}
排序过程
将所有距离为gap的元素分在同一组，并分为三个逻辑分组，并对每一组的元素进行直接插入排序，所有分组预排序完，最后在进行一次插入排序；或者按直接插入理解，直接插入的gap是1，这里是3
希尔排序优化
void ShellSort1(int* arr, int n)
{
int gap = n;
while (gap >= 1)
{
int i;
gap = gap / 2;
for (i = 0; i < n - gap; i++)
{
int end = i;
int x = arr[end + gap];
while (end >= 0)
{
if (arr[end] > x)
{
arr[end + gap] = arr[end];
end -= gap;
}
else
break;
}
arr[end + gap] = x;
}
}
}
gap越大，预排越快，越不接近有序，gap除2可以保证最后剩下1，用于直接插入排序
希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
- 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N1.3—N2）
- 稳定性：不稳定
插入排序：
希尔是在直插上多了预排序的步骤，但他们的主要做法是按顺序把序列本身逐次变为有序，即把第一个数看成一个有序序列，把第二个数插入的到这个序列就会得到新的有序序列，以此类推
选择排序
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
选择排序
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素，若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
代码实现
这里先写一下交换模块，后面都会用得到
void swap(int* temp,int* temp2)
{
int a = *temp;
*temp = *temp2;
*temp2 = a;
}
代码实现
void SelecSort1(int *arr,int n)
{
assert(arr);
for(int i = 0;i < n-1;i++)
{
int begin = i;
for(int j = i;j < n;j++)
{
if(arr[begin] < arr[j])
begin = j;
}
swap(arr[begin],arr[i]);
}
}
第一趟记录最小值的下标，等待遍历完后，把记录的下标和最开始位置交换，之后从第二个位置开始进行第二躺比较并找到最小值的下标，之后再次和第二个位置交换以此类推，一共执行n-1躺，因为剩的最后一个数会因为前面已经排序完而自然变为有序的
选择排序优化
void SelecSort1(int *arr, int n)
{
assert(arr);
int begin = 0;
int end = n - 1;
while (begin < end)
{
int max = end;
int min = begin;
for (size_t i = begin; i <= end; i++)
{
if (arr[i] < arr[min])
min = i;
if (arr[i] > arr[max])
max = i;
}
swap(arr[begin], arr[min]);
if (max == begin)
max = min;
swap(arr[end], arr[max]);
begin++;//每趟的起始位置
end--;//每趟的终止位置
}
}
直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
优化的选择排序多了一个记录最大值位置的下标，和最小值一样，把找到的最大值下标与最后位置交换；每趟执行会使起始位置和结束位置缩进，直到起始位置大于等于结束位置
注意：假如最大值大小表示起始位置的下标，当起始位置和最小值位置下标交换完数后，最大位置被换到min下标处了，这时需要把min下标位置赋给max（若先交换的大值，则需要反过来）
堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
堆排序在前面二叉树中已经介绍过了，这里就不过多介绍了
主要步骤：
1.先把数组加入到堆中，利用向下调整，因为向下调整（N）的时间复杂度比向上调整（logN）要好，向下调整的位置是最后一个叶节点的parent，因为叶节点不需要调整，已经是堆的最后一层了，所以从最后一个parent开始向下调整也就是最后一个叶节点的parent（可以看成倒序的层序遍历并向下调整每个节点）
2.因为堆顶是最值，先把堆顶的值与末尾的值交换，在重新向下调整，并且边界暂时不包括刚交换完后的数
代码实现
1.先把数组加入到堆
向下调整
void Down(int* a,int size,int parent)
{
int child = parent*2+1;
while(child < size)
{
if(child+1 < n && a[child+1] > a[child])
child++;
if(a[child] > a[parent])
{
swap(a+child,a+parent);
parent = child;
child = parent*2+1;
}
else
break;
}
}
建堆
void add_Heap(int* a,int size)
{
int i;
for(i = (size-1-1)/2;i >= 0;i--)
Down(a,size,i);
}
排序
void HeapSort(int* a,int n)
{
int i;
for(i = size-1;i > 0;i--)
{
swap(a,a+i); //先交换
Down(a,i,0); //再调整，调整的size不包括刚换的后面的的位置
}
}
堆排序的重点在于用数组本身的空间先把数组加入到堆，堆顶是最值，把最值交换到末尾继续向下调整出次最值，向下调整的边界不包括刚刚换下来的数值位置
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
交换排序
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排
序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
冒泡排序
冒泡排序应该是最早学会的一种排序，一共执行 总个数-1 躺，第一趟将一个最值数放置末尾（开头），第二趟将次最值数放置倒数第二个 位置（或第二个位置）执行n-1躺后就剩一个元素，其他元素已经排序好了
排序过程
直到把本趟最大的数放置在最后面位置
第二趟再把第2个大的数放置在倒数第2个位置，以此类推一共执行 总个数-1趟，因为前面几趟排序已经排序好了n-1个数了，剩下的一个数自然是有序的
代码实现
void BubblesOrt(int* a,int n)
{
int i;
for(i = 0;i < n-1;i++)
{
int j;
for(j = 0;j < n-i-1;j++) //-1是因为 假如最后交换时，是 i和i+1交换
{
if(arr[i] > arr[i+1])
swap(a[i],a[i+1]);
}
}
}
但是假如数组是有序的或者非常接近有序，执行一两趟就有序了，那这么做就有点浪费时间了
代码优化
定义一个标志位，对每趟进行检测，若发生交换就改变标志位，若不发生交换就证明是有序的，就退出
void BubblesOrt(int* a,int n)
{
int i;
for(i = 0;i < n-1;i++)
{
int flag = 1;
int j;
for(j = 0;j < n-i-1;j++)
{
if(arr[i] > arr[i+1])
{
swap(a[i],a[i+1]);
flag = 0;
}
}
if(flag)
return;
}
}
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：
- hoare版本
- 挖坑法
- 前后指针版本
hoare版本
先定义一个变量Key，Key的取值可以是最左边也可以是最右边
单趟排序：
若定义的是最左边，则右边先走
1.右边负责找比Key小的数，找到就停下，换左边走
2.左边找到比Key大的数停下，左右两边交换
3.之后继续重复上面的过程，直到左右相遇，就把相遇位置的数和Key位置的数交换，此时相遇位置的 数就是有序的
相遇位置一定比Key小（右边先走）：
因为在相遇之前的最后一次交换，是左边把比key位置大的数换给右边，右边把比key位置小的数换给左边，之后右边继续执行，直到右边撞上左边
代码实现
int _QuickSort1(int* a, int left, int right)
{
int key = left;
while (left < right)
{
while (a[right] >= a[key] && left < right)
right--;
while (a[left] <= a[key] && left < right)
left++;
swap(a[left], a[right]);
}
swap(a[left],a[ key]);
key = left;
return key;
}
注意： && left < right一定不能省略，假如当key都是一样大或者交换两次后剩下的都是一样大的时候，right就会一直减会越界
多趟排序
多趟排序则可以用分治思想：
第一趟已经把一个数排到有序位置，则可以按这个数为分割线，把数组分为左右两个数组，再执行排一趟的程序找出一个数的有序位置，等他们排完了继续按有序数的位置再分为左右两个数组一直到把数组分成剩一个元素为止
代码实现
void QuickSort(int* a, int left, int right)
{
assert(a);
if (left >= right)
return;
int key = _QuickSort1(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1,right);
}
非常类似二叉树的前序遍历，先求根的位置，再分为左子树和右子树
代码优化1：当出现数组是有序或接近有序时的问题
但是快排在极端情况下会变得很慢，例如数组有序或者接近有序
因为栈帧的空间是不大的，当数的特别大且接近有序时，递归的深度就会特别深，中途可能就会导致栈溢出
改进办法：取一个中间位置的值，与right和left位置进行比较，取出中间值与（Key位置）左或右交换
代码优化1
int Mid(int* a,int right,int left)
{
int mid = left+(right-left)/2;
if(a[mid] > a[left])
{
if(a[left] > a[right])
return left;
else if(a[right] > a[mid] )
return mid;
else
return right;
}
else
{
if(a[mid] > a[right])
return mid;
else if(a[right] > a[left] )
return left;
else
return right;
}
}
int _QuickSort1(int* a, int left, int right)
{
int mid = Mid(a, right, left);
swap(a + mid, a + left);
int key = left;
while (left < right)
{
while (a[right] >= a[key] && left < right)
right--;
while (a[left] <= a[key] && left < right)
left++;
swap(a[left], a[right]);
}
swap(a[left],a[ key]);
key = left;
return key;
}
代码优化2：小区间优化问题
由上图可知，越接近底层，越有序，如果还继续用递归，就会有些浪费，这个时候可以用直接插入排序，对小区间进行优化，例如数组分割完剩10个元素时
代码优化2
void QuickSort(int* a, int left, int right)
{
assert(a);
if (right <= left)
return;
if (right - left + 1 <= 10)
{
Insert_sort(a + left, right - left + 1);
return;
}
int key = _QuickSort1(a, left, right);
QuickSort(a, left, key-1);
QuickSort(a, key+1, right);
}
注意：调用直接插入排序时，由于数组是长数组分割来的，起始位置并不一定是0位置，所以要加上每次的left（Insert_sort(a+left,right - left+1)）
例如：一共21个数组，第一次排序好一个有序位置（这个位置正好在中间），之后进行分治，左右两边各10个，左边的起始位置是0，右边的起始位置是key+1，将key+1作为 新的left递至下一层
所以在调用直接插入排序时，一定要记得数组的起始位置要加上本层的left
挖坑法
挖坑法是在hoare版的基础上稍加改进的
是把hoare版中每次交换的步骤变为填坑的步骤，key存左边或右边的值（以存左边举例）
1.右边先走找比key小的数，找到后放到“坑中”是left的位置，right变为新的坑
2.左边走，直到找到比key大的数，找到后把数放到“坑中”right的 位置，left变为新的坑
3.重复上面的步骤，直到左右相遇，这时把key放到相遇的“坑中”
代码实现
int _QuickSort2(int* a, int left, int right)
{
assert(a);
int mid = Mid(a, right, left);
swap(a + left, a + mid);
int key = a[left];
int pivot = left;
while (left < right)
{
while (a[right] < key && left < right)
right--;
a[pivot] = a[right];
pivot = right;
while (a[left] > key && left < right)
left--;
a[pivot] = a[left];
pivot = left;
}
a[pivot] = key;
return pivot;
}
前后指针法
思路：
1.定义两个指针，cur和prev，若key的值是左边，则prev就是开始的位置，cur = prev+1的位置，key是右边值，prev就是末尾位置，cur = prev-1；
2.先对cur进行判断若cur所在位置小于key值，则prev先增1，之后prev与cur交换；若cur大于key则不执行交换和prev自增
3.cur++ （或–）
直到cur超出范围停止,并交换prev
代码实现
int _QuickSort3(int* a, int left, int right)
{
assert(a);
int mid = Mid(a, left, right);
swap(a + left, a + mid);
int key = left;
int prev = left;
int cur = prev + 1;
while (cur <= right)
{
if (a[cur] < a[key])
{
prev++;
swap(&a[cur], &a[prev]);
}
cur++;
}
swap(a[key], a[prev]);
return prev;
}
cur就是负责找小，prev负责找大；cur位置值小于key位置值时，prev和cur都自增，当cur位置的值大于key位置的值时cur自己自增
说明当cur自己移动后，prev的当前位置一定是比key位置值小的数，prev的下一个位置一定是比key位置值大的
等待cur再次找到小值时，prev增1后，将这两个值交换，若cur超出范围，说明没有比key位置值大的，所以就交换prev当前位置的值与key位置的值
代码优化：
当cur位置的值小于key位置的值时，prev自增后与cur位置交换数值，假如前几个数都是小于key的数，prev先自增，但与cur位置相同了，再交换，会重复很多次自己与自己交换
int _QuickSort3(int* a, int left, int right)
{
assert(a);
int mid = Mid(a, right, left);
int key = left;
int prev = left;
int cur = prev + 1;
while (cur <= right)
{
if (a[cur] < a[key] && cur != ++prev) //或者a[++prev]
swap(a + cur, a + prev);
cur++;
}
swap(a+prev, a+key);
return prev;
}
if(a[cur] < a[key] && cur != ++prev)
先判断左边，若左边为假则不进入执行交换，若为真再判断，cur的位置与prev自增后的位置是否相同，因为++prev在条件语句中，每一次进行判断的时候他都会执行一次，所以当cur满足小于key时，但cur等于prev自增后的数就不执行交换
注意：一定要使用前置++，因为优先级的关系，后置自增是先输出数再自增，前置++是先自增再输出数
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
非递归法（用栈模拟）
由于递归是在栈帧中不断申请内存，虽然函数结束时系统会收回，但当深度很深时，还未到达底层时，中途可能就会栈溢出，所以这里再介绍一下非递归的实现
需要用到栈（数据结构中的栈），栈的原则是先进后出，后进先出
先看代码实现
栈的相关函数
typedef struct Stack
{
int size;
int capacity;
int* arr;
}SK;
初始化
void Stack_init(SK* ps)
{
ps->arr = NULL;
ps->capacity = 0;
ps->size = 0;
}
释放
void Stack_Destroy(SK* ps)
{
assert(ps->arr);
ps->arr = NULL;
ps->size = 0;
ps->capacity = 0;
}
扩容
void address(SK* ps)
{
if(ps->size == ps->capacity)
{
int newsize = ps->capacity == 0?4:ps->capacity*2;
int* temp = (int*)realloc(ps->arr,sizeof(int)*newsize);
if(temp == NULL)
{
perror("realloc");
exit(-1);
}
ps->arr = temp;
ps->capacity = newsize;
}
}
判断栈是否为空
int StackEmpty(SK* ps)
{
assert(ps);
return ps->size == 0;
}
取栈顶内容
int Stack_top(SK* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->arr[ps->size-1];
}
入栈
void Stack_Push(SK* ps, int x)
{
assert(ps);
address(ps);
ps->arr[ps->size] = x;
ps->size++;
}
出栈
void Stack_pop(SK* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->size--;
}
-----------------------------------------------------------------------------------------------
排序一趟
int Quicksort(int* a,int left,int right)
{
int mid = Mid(a,right,left);
swap(a+left,a+mid);
int key = left;
int prev = left;
int cur = prev+1;
while(cur <= right)
{
if(a[cur] < a[key] && cur != ++prev)
swap(a+cur,a+prev);
cur++;
}
swap(a+prev,a+key);
return prev;
}
多趟排序
void StackQuicksort(int* a,int right,int left)
{
assert(a);
SK temp;
Stack_init(&temp);
Stack_Push(&temp, left);
Stack_Push(&temp, right);
while(!StackEmpty(&temp))
{
int end = Stack_top(&temp);
Stack_pop(&temp);
int begin = Stack_top(&temp);
Stack_pop(&temp);
int key = Quicksort(a,int begin,int end);
if(key+1 < end)
{
Stack_Push(&temp, key+1);
Stack_Push(&temp, end);
}
if(begin < key-1)
{
Stack_Push(&temp, begin);
Stack_Push(&temp, key-1);
}
}
Stack_Destroy(&temp);
}
先临时创建一个栈并初始化
1.先把最开始的左右下标入栈，这里是打算先取末尾下标再取开头下标，所以先入的开头下标后入的末尾下标
2.之后进入循环取栈顶的数，取两次
3.把取出的下标再传入到排一趟的函数中并返回排序好那一个数的下标
4.之后按取到的key值，分为左右两个区间数组，先入右区间的就会后出右区间的，先入左区间的就会后出左区间的，并且数组中只有一个元素时肯定是有序的，对此也需要进行判断
直到出栈为空停止并释放临时创建的栈
图解如下：
栈模拟主要是注意根据栈的原则“选进后出”，确定入下标和取下标的顺序，并且也不会存在栈溢出的可能，因为每次调用也只是申请一块内存，调用结束随即销毁，下次调用在申请之后再销毁
归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
排一趟
假设有两个数组，这两个数组都是有序的，把这个数组合并为一个有序的数组
以排升序为例
int* _MergeSort(int* a,int asize，int* b,int bsize)
{
int* temp = (int*)malloc(sizeof(4)*(asize+bsize));
int i = 0;
int begin1 = 0,end1 = asize-1;
int begin2 = 0,end2 = bsize-1;
while(begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] < b[begin2])
temp[i++] = a[begin1++];
else
temp[i++] = b[begin2++];
}
while(begin1 <= end1)
temp[i++] = a[begin1++];
while(begin2 <= end2)
temp[i++] = b[begin2++];
return temp;
}
递归法
对一个乱序数组进行排序，就是在排一趟的基础上进行改进，类似插入排序，归并的前提是，按中间下标分割，左右两个区间的数组必须是有序的；
想要左右数组有序，可以继续分成左右数组，（1分为2，2分为4）直到左右区间只有各一个元素，那他们一定是有序的，就可以将左右区间合并，合并完的数组归并回上一层继续与另一边排好的数组归并，直到归并回最初的数组
代码实现
void _MergeSort(int* a,int left,int right,int* temp)
{
if(left >= right)
return;
int mid = left + (right-left)/2;
int begin1 = left,end1 = mid;
int begin2 = mid+1,end2 = right;
_MergeSort(a,left,mid,temp);
_MergeSort(a,mid+1,right,temp);
int i = left;
while(begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] < a[begin2])
temp[i++] = a[begin1++];
else
temp[i++] = a[begin2++];
}
while(begin1 <= end1)
temp[i++] = a[begin1++];
while(begin2 <= end2)
temp[i++] = a[begin2++];
for(i = left;i <= right;i++)
{
a[i] = temp[i];
}
}
void MergeSort(int* a,int n)
{
int* temp = (int*)malloc(sizeof(int)*n);
if(temp == NULL)
{
perror("malloc");
exit(-1);
}
_MergeSort(a,0,n-1,temp);
free(temp);
temp == NULL;
}
也类似二叉树的后序遍历，先把左边排好，再把右边排好，最后对“根”处理归并
但最需要注意的是每层的开始位置与结束位置，影响的是原数组取值到临时数组和临时数组排好赋回给原数组的对应位置
所以对原数组取值到临时数组的位置必须是对应的，临时数组排序完赋值给原数组的位置也必须是对应的，也就是每层的left就是开始位置，right是结束位置；只要位置是对应的，left-right只会影响到这个区间内的数，避免出现误把区间以外的数丢失等
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
非递归法（循环模拟）
非递归法的思路：
和希尔排序类似，先把数组分为间隔距离为1的子数组，对子数组两两排序
再按间隔距离为2分为子数组进行两两排序
再按间隔距离为4进行分组两两排序
最后得到有序数组
void MergeSortNond(int* a,int n)
{
int gap = 1;
int* temp = (int*)malloc(sizeof(int)*n);
if(temp == NULL)
{
perror("malloc");
exit(-1);
}
while(gap < n)
{
int i;
for(i = 0;i < n;i += 2*gap)
{
int begin1 = i,end1 = i+gap-1;
int begin2 = i+gap,end2 = i+gap*2-1;
int j = i;
if(end1 >= n)
{
end1 = n-1;
begin2 = n-1;
end2 = n-1;
}
else if(begin2 >= n)
{
begin2 = n-1;
end2 = n-1;
}
else if(end2 >= n)
{
end2 = n-1;
}
while(begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] < a[begin2])
temp[j++] = a[begin1++];
if(a[begin1] < a[begin2])
temp[j++] = a[begin2++];
}
while(begin1 <= end1 && j < n) //在发生越界时，可能会把end1和end2的位置都是最后一个
temp[j++] = a[begin1++]; //在上面循环退出时，temp就可能会越界
while(begin2 <= end2 && j < n)
temp[j++] = a[begin2++];
}
for(j = 0;j<n;j++)
a[j] = temp[j];
gap*=2;
}
}
但是，上述情况gap必须是12222…，所以当出现奇数或者被2除完是奇数等就需要额外考虑了
例如数组个数变为9个
所以当end1越界时，begin2，end2必越界；当begin2越界时，end2比越界；也可能end2自己越界
gap=1时
gap=2时
gap=4时
gap=8时
最后数组为
非递归的相对于递归的方法还是比较麻烦的，需要考虑越界，gap间距，左右两个数组的开始和结束 下标等
总结
1289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
