基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
在代码中添加了exchange是为了提高一下数据在有序情况以下的效率。
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
int exchange = 0;
for (int j = 1; j < n - i; j++)
{
if (a[j - 1] > a[j])
{
swap(&a[j - 1], &a[j]);
exchange = 1;
}
}
if (exchange == 0)
{
break;
}
}
}
冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：
O(N^2)- 空间复杂度：
O(1)- 稳定性：稳定
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
这里一共有几个不同的写法：hoare版本、 挖坑法、前后指针版本
hoare版本
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)//递归结束
{
return;
}
int left = begin;
int right = end;
int keyi = begin;
while (left < right)
{
while (left < right && a[right] >= a[keyi])
{
right--;
}
while (left < right && a[left] <= a[keyi])
{
left++;
}
swap(&a[right], &a[left]);
}
swap(&a[left],&a[keyi]);
keyi = left;
QuickSort(a,begin,keyi-1);
QuickSort(a, keyi+1,end);
}
上面的代码，可以计算出在理想状态下时间复杂度是
O(N*logN)，和希尔、堆排是同一量级的，但是在不是理想状态下（数据处于有序，或者key处于在数据最大或者最小时）时间复杂度是O(N^2)，在不理想状态下也就相当于冒泡排序。而且快排使用到了递归，使用了递归我们就必须要注意对栈帧的使用，防止栈溢出。
以上的问题使用两种方法来解决：三数取中、小区间优化。
三数取中：很好的解决了key处于最大值或者最小值的问题，也就避免了时间复杂度出现O(N^2)的情况。
小区间优化：因为在之前我们也学习过树的结构，最低层的数据就占全部数据的一半，所以我们在大区间使用递归，小区间直接使用插入排序，为了减少递归使用的次数，从而造成栈溢出的问题。
int GetMidIndex(int* a, int begin, int end)
{
//三数取中
int mid = (begin + end) / 2;
if (a[end] > a[mid])
{
if (a[mid] > a[begin])
{
return mid;
}
else if(a[begin]>a[end])
{
return end;
}
else
{
return begin;
}
}
else
{
if (a[begin] > a[mid])
{
return mid;
}
else if(a[end]>a[begin])
{
return end;
}
else
{
return begin;
}
}
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)//递归结束
{
return;
}
//小区间优化
if ((end - begin + 1) < 15)
{
// 小区间用直接插入替代，减少递归调用次数
InsertSort(a+begin, end - begin + 1);
}
else
{
//三数取中，对快排进行优化
int mid = GetMidIndex(a, begin, end);
swap(&a[begin], &a[mid]);
int left = begin;
int right = end;
int keyi = left;
while (left < right)
{
while (left < right && a[right] >= a[keyi])
{
right--;
}
while (left < right && a[left] <= a[keyi])
{
left++;
}
swap(&a[right], &a[left]);
}
swap(&a[left], &a[keyi]);
keyi = left;
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
}
挖坑法
挖坑法的思路是：同样的用三数取中求出
keyi，也就是左边的第一个数据，再用一个变量将第一个设为坑，从右开始找出小于keyi的值，将该数放到坑中，再将此位置从新设为坑，然后再从左边开始遍历，找出大于keyi的值，以此类推，最后相遇在坑上，将keyi放在坑中，在依次遍历。
//挖坑法
int PartSort2(int* a, int begin, int end)
{
int mid = GetMidIndex(a, begin, end);
swap(&a[begin], &a[mid]);
int left = begin;
int right = end;
int keyi = a[left];
int hole = left;
while (left < right)
{
while (left < right && a[right] >= keyi)
{
right--;
}
a[hole] = a[right];
hole = right;
while (left < right && a[left] <= keyi)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = keyi;
return hole;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)//递归结束
{
return;
}
//小区间优化
if ((end - begin + 1) < 15)
{
// 小区间用直接插入替代，减少递归调用次数
InsertSort(a+begin, end - begin + 1);
}
else
{
int keyi = PartSort2(a,begin,end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
}
前后指针法
前后指针法思路是：从最左边设置两个前后指针，
cur在prev的前一个，cur先移动碰到比keyi小的数就将++prev进行交换，直至cur到达尾部。再将keyi和prev位置的值进行交换再将prev位置设置为新的keyi
//前后双指针法
int PartSort3(int* a, int begin, int end)
{
int mid = GetMidIndex(a, begin, end);
swap(&a[begin], &a[mid]);
int keyi = begin;
int prev = begin;
int cur = begin + 1;
while (cur <= end)
{
if( ++prev!=cur&& a[cur]<a[keyi])
{
swap(&a[prev], &a[cur]);
}
cur++;
}
swap(&a[prev], &a[keyi]);
keyi = prev;
return keyi;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)//递归结束
{
return;
}
//小区间优化
if ((end - begin + 1) < 15)
{
// 小区间用直接插入替代，减少递归调用次数
InsertSort(a+begin, end - begin + 1);
}
else
{
int keyi = PartSort3(a,begin,end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
}
非递归写法
上面已经介绍完递归的写法，因为一提到递归的问题首先就应该想到的栈溢出的问题，所以就介绍了非递归的写法。
非递归思路：这里我们借用到了栈（当然不是只能使用栈，队列也是可以的，只是用栈更加符合递归的流程）将数据两头的数据进行入栈，还是接入上面的三种方法（hoare，挖坑法，前后指针）然后取到keyi分割为两部分继续进行入栈。
//快排非递归
void QuickSortNonR(int* a, int begin, int end)
{
ST st;
StackInit(&st);
StackPush(&st,begin);
StackPush(&st,end);
while (!StackEmpty(&st))
{
int right=StackTop(&st);
StackPop(&st);
int left = StackTop(&st);
StackPop(&st);
int keyi = PartSort3(a, left,right);
if (keyi + 1<right)
{
StackPush(&st, keyi+1);
StackPush(&st, right);
}
if (keyi - 1 > begin)
{
StackPush(&st, begin);
StackPush(&st, keyi-1);
}
}
StackDestroy(&st);
}
解决数据当中有大量重复数据，或者全是相同数据效率的问题
我们上面提供的代码已经可以解决大部分的问题了，但是有时在写
OJ的情况下会发现再碰到一些特殊用例并不能高效的解决，也就不能通过测试用例。上面的代码时间复杂度是O(N*logN)但是在特殊情况下时间复杂度是O(N^2)，所以提出了解决的方法，在我们上面应用的方法可以把他们称为两路划分，而我们要解决的问题的方法称为三路划分。
解题思路：将数据分为三部分，前面是小于keyi的而中间放和keyi相等的，后面放大于keyi的，这样如果再碰到数据全是相同的也能很好的解决。
在这里我们再继续使用三数取中来完成OJ是行不通的了，可能大量区间选keyi让你选到比较小的或者比较大的，导致性能下降，座椅解决方案就是：结合随机选keyi优化。
void swap(int* a, int* b)
{
int temp = 0;
temp = *a;
*a = *b;
*b = temp;
}
int GetMidIndex(int* a, int begin, int end)
{
//int mid = (begin + end) / 2;
int mid=begin+rand()%(end-begin);
if (a[end] > a[mid])
{
if (a[mid] > a[begin])
{
return mid;
}
else if(a[begin]>a[end])
{
return end;
}
else
{
return begin;
}
}
else
{
if (a[begin] > a[mid])
{
return mid;
}
else if(a[end]>a[begin])
{
return end;
}
else
{
return begin;
}
}
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)//递归结束
{
return;
}
//小区间优化
if ((end - begin + 1) < 15)
{
// // // 小区间用直接插入替代，减少递归调用次数
InsertSort(a+begin, end - begin + 1);
}
else
{
int mid=GetMidIndex(a,begin,end);
swap(&a[mid],&a[begin]);
int left=begin;
int right=end;
int keyi=a[begin];
int cur=begin+1;
while(cur<=right)
{
if(a[cur]>keyi)
{
swap(&a[cur],&a[right]);
//cur++;
right--;
}
else if(a[cur]<keyi)
{
swap(&a[cur],&a[left]);
cur++;
left++;
}
else
{
cur++;
}
}
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}
}
快速排序的特性总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：
O(N*logN)- 空间复杂度：
O(logN)- 稳定性：不稳定
基本思想：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
递归写法：
void _MergeSort(int* a,int begin,int end,int *tmp)
{
if (begin >= end)
{
return;
}
int mid = (begin + end) / 2;
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid+1, end, tmp);
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
memcpy(a+begin,tmp+begin,sizeof(int)*(end-begin+1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int)*n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
_MergeSort(a,0,n-1,tmp);
free(tmp);
tmp = NULL;
}
非递归写法：
上面已经介绍完递归的写法，因为一提到递归的问题首先就应该想到的栈溢出的问题，所以就介绍了非递归的写法。
非递归思路：这里我们借用到了rangeN变量来控制每次归并的数量，这里还要解决的一个问题就是当数据的个数不是2的几次方的情况下就会出现随机数的问题，所以每次在归并前都要进行一下是否需要修正的判断。每次进行归并的间距是begin1，end1和begin2,end2进行归并，而出现随机数的情况只有三种，就是end1到最后，begin2到最后，end2到最后，只有这三种情况，将这三种情况控制住就可以实现非递归的归并了。
控制随机数的方法也是有两种：一是整体拷贝。二是部分拷贝。
整体拷贝
//整体拷贝
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * (n));
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
int rangeN = 1;
while (rangeN < n)
{
for (int j = 0; j < n; j += rangeN * 2)
{
int begin1 = j, end1 = j + rangeN - 1;
int begin2 = j + rangeN, end2 = j + 2 * rangeN - 1;
int i = j;
//修正
if (end1 >= n)
{
end1 = n - 1;
//不存在的区间
begin2 = n;
end2 = n - 1;
}
else if (begin2 >= n)
{
begin2 = n;
end2 = n - 1;
}
else if (end2 >= n)
{
end2 = n - 1;
}
//归并
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
}
//整体拷贝
memcpy(a, tmp, sizeof(int) * n);
rangeN *= 2;
}
free(tmp);
tmp = NULL;
}
部分拷贝
//部分拷贝
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * (n));
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
int rangeN = 1;
while (rangeN < n)
{
for (int j = 0; j < n; j += rangeN * 2)
{
int begin1 = j, end1 = j + rangeN - 1;
int begin2 = j + rangeN, end2 = j + 2 * rangeN - 1;
int i = j;
//修正
if (end1 >= n)
{
break;
}
else if (begin2 >= n)
{
break;
}
else if (end2 >= n)
{
end2 = n - 1;
}
//归并
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
//部分拷贝
memcpy(a+j, tmp+j, sizeof(int) * (end2-j+1));
}
rangeN *= 2;
}
free(tmp);
tmp = NULL;
}
归并排序的特性总结：
- 归并的缺点在于需要
O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。- 时间复杂度：
O(N*logN)- 空间复杂度：
O(N)- 稳定性：稳定
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
| 最后：文章有什么不对的地方或者有什么更好的写法欢迎大家在评论区指出 |
| 现在是2022年12月29日也是22年的最后一天，在这里也简单进行一下2022年的小总结。我是从暑假的时候开始学习的，虽说是学习到了东西，但是大部份时间还是在进行摆烂，在学校的日子还算可以身边人也能带动我学习但是一回到家还是没有自控力，说白了还是太懒了。在新的一年里希望更加的自律，坚持完成每一天的任务，少想多做，要让自己看到行动，要动起来！！！！！ 在22年的最后一天，对23年的自己说一声加油！！！！ |
