「这是我参与2022首次更文挑战的第5天，活动详情查看：2022首次更文挑战」 [toc]
排序
常见的排序算法
image-20211119082822804
常见排序算法的实现
冒泡排序 也是我们本身接触最早的排序 很简单的一个排序
image-20211121230122796
// 冒泡排序
void BubbleSort(int* a, int n) {
//多躺
int j = 0;
for (j = 0; j < n - 1; j++) {
//单趟
int i = 0;
for (i = 0; i < n - 1-j; i++) {
if (a[i] > a[i + 1]) {
Swap(&a[i], &a[i + 1]);
}
}
}
}
但是我们可以优化一下吗，就是原本就是有序的情况下，我们还要走多趟吗 ？反正上面的代码是必走的
我们可以发现正常的是只要遍历一次发现有序了就不会再来第二遍，所以我们要优化一下代码
image-20211122000720968
加了标记后，就可以达到上面那个动图遍历一遍没有变化就直接出来的效果
完整冒泡排序代码
// 冒泡排序
void BubbleSort(int* a, int n) {
//多躺
int j = 0;
for (j = 0; j < n - 1; j++) {
//交换标记变量
int flag = 0;
//单趟
int i = 0;
for (i = 0; i < n - 1-j; i++) {
//交换标记改变
flag = 1;
if (a[i] > a[i + 1]) {
Swap(&a[i], &a[i + 1]);
}
}
//标记还是0就跳出
if (!flag)
break;
}
}
冒泡排序时间复杂度O(N^2^)
最好：O(N)
最坏：O(N^2^)
到再来我们可以把同级别的插入排序，选择排序，冒泡排序拉出来对比一下
横向对比
选择最差，因为无论最好还是最坏都是O(N^2^)
直接插入和冒泡最好情况下是O(N)，最坏是O(N^2^)
但是肯定有人也想比较一下直接插入和冒泡
**在已经有序的情况下：**两个是一样好的
**在接近有序的情况下：**直接插入比冒泡要好，因为单一个找到需要插（交换）的，直接插入就直接插入，然后就不需要再跑了；然而冒泡还要排序到尾部，这就是比直接插入比有点小小的不如的地方
所有代码
Sort.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#define HEAP 1
// 排序实现的接口
// 打印数组
extern void PrintArray(int* a, int n);
// 插入排序
extern void InsertSort(int* a, int n);
// 希尔排序
extern void ShellSort(int* a, int n);
//数据交换
extern void Swap(int* pa, int* pb);
// 选择排序
extern void SelectSort(int* a, int n);
//向下调整
extern void AdjustDwon(int* a, int n, int parent);
// 堆排序
extern void HeapSort(int* a, int n);
// 冒泡排序
extern void BubbleSort(int* a, int n);
Sort.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Sort.h"
#include"Stack.h"
// 打印数组
void PrintArray(int* a, int n) {
assert(a);
int i = 0;
for (i = 0; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
// 插入排序
void InsertSort(int* a, int n) {
assert(a);
int i = 0;
for (i = 0; i < n - 1; i++) {
int end = i;
int x = a[end+1];
while (end >= 0) {
//要插入的数比顺序中的数小就准备挪位置
if (a[end] > x) {
a[end + 1] = a[end];
end--;
}
else {
//插入的数比顺序中的要大就跳出
break;
}
}
//跳出来两种情况
//1.end == -1 的时候
//2.break 的时候
//把x给end前面一位
a[end + 1] = x;
}
}
// 希尔排序
void ShellSort(int* a, int n) {
//分组
int gap = n;
//多次预排序（gap>1）+ 直接插入（gap == 1）
while (gap>1){
//gap /= 2;
//除以三我们知道不一定会过1，所以我们+1让他有一个必过1的条件
gap = gap / 3 + 1;
//单组多躺
int i = 0;
for (i = 0; i < n - gap; i++) {
int end = i;
int x = a[end + gap];
while (end >= 0) {
if (a[end] > x) {
a[end + gap] = a[end];
//步长是gap
end -= gap;
}
else {
break;
}
}
a[end + gap] = x;
}
}
}
//数据交换
void Swap(int* pa, int* pb) {
int tmp = *pa;
*pa = *pb;
*pb = tmp;
}
// 选择排序
void SelectSort(int* a, int n) {
int begin = 0;
int end = n - 1;
while (begin < end){
//单趟
//最大数，最小数的下标
int mini = begin;//这边假设是刚开始的下标
int maxi = end; //这边假设是末尾的下标
int i = 0;
for (i = begin; i <= end; i++) {
if (a[i] < a[mini])
mini = i;
if (a[i] > a[maxi])
maxi = i;
}
//最小的放前面
Swap(&a[begin], &a[mini]);
if (begin == maxi)
//如果最大数就是begin位置的，那么交换的时候最大数连带着下标一起动
maxi = mini;
//最大的放后面
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
//向下调整函数
void AdjustDown(int* a, int n, int parent)
{
assert(a);
//创建一个孩子变量，有两个孩子就在这个上加1就行
int child = parent * 2 + 1;
#if HEAP
while (child < n)
{
//选大孩子
if (child + 1 < n && a[child] < a[child + 1])
{
child++;
}
//大的孩子还大于父亲就交换
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
#elif !HEAP
while (child < n)
{
//选小孩子
if (child + 1 < n && a[child] > a[child + 1])
{
child++;
}
//小的孩子还小于父亲就交换
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
#endif // HEAP
}
// 堆排序 我们之前讲过升序建大堆
void HeapSort(int* a, int n) {
//建堆时间复杂度O(N)
//建大堆
int i = 0;
for (i = (n - 1 - 1) / 2; i >= 0; i--) {
AdjustDown(a, n, i);
}
int end = n - 1;
//堆排序时间复杂度O(N*logN)
while (end>0){
//交换 把最大的放到后面
Swap(&a[0], &a[end]);
//在向下调整
AdjustDown(a,end,0);
end--;
}
}
// 冒泡排序
void BubbleSort(int* a, int n) {
//多躺
int j = 0;
for (j = 0; j < n - 1; j++) {
//交换标记变量
int flag = 0;
//单趟
int i = 0;
for (i = 0; i < n - 1-j; i++) {
//交换标记改变
flag = 1;
if (a[i] > a[i + 1]) {
Swap(&a[i], &a[i + 1]);
}
}
//标记还是0就跳出
if (!flag)
break;
}
}
//三数取中
int GetMinIndex(int* a, int left, int right) {
//这样可以防止 int 溢出
int mid = left + (right - left) / 2;
if (a[left] < a[mid]) {
if (a[mid] < a[right])
return mid;
else if (a[left] > a[right])
return left;
else
return right;
}
else //a[left] >= a[mid]
{
if (a[mid] > a[right])
return mid;
else if (a[left] < a[right])
return left;
else
return right;
}
}
}
test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Sort.h"
// 测试排序的性能对比
void TestOP()
{
//设置随机起点
srand(time(NULL));
//将要创建的数组大小
const int N = 10000;
int* a1 = (int*)malloc(sizeof(int) * N);
int* a2 = (int*)malloc(sizeof(int) * N);
int* a3 = (int*)malloc(sizeof(int) * N);
int* a4 = (int*)malloc(sizeof(int) * N);
int* a5 = (int*)malloc(sizeof(int) * N);
int* a6 = (int*)malloc(sizeof(int) * N);
for (int i = 0; i < N; ++i)
{
//保证两个数组是一样的
a1[i] = rand();
a2[i] = a1[i];
a3[i] = a1[i];
a4[i] = a1[i];
a5[i] = a1[i];
a6[i] = a1[i];
}
int begin1 = clock();//开始时间
//InsertSort(a1, N);
int end1 = clock(); //结束时间
int begin2 = clock();
ShellSort(a2, N);
int end2 = clock();
int begin3 = clock();
//SelectSort(a3, N);
int end3 = clock();
int begin4 = clock();
HeapSort(a4, N);
int end4 = clock();
int begin4_1 = clock();
HeapSort(a2, N);
int end4_1 = clock();
int begin5 = clock();
//BubbleSort(a5, N);
int end5 = clock();
int begin6 = clock();
QuickSort(a6, 0, N - 1);
int end6 = clock();
int begin6_1 = clock();
QuickSort(a2,0,N-1);
int end6_1 = clock();
printf("InsertSort:%d\n", end1 - begin1);//结束时间减去开始时间
printf("ShellSort:%d\n", end2 - begin2);
printf("SelectSort:%d\n", end3 - begin3);
printf("HeapSort:%d\n", end4 - begin4);
printf("HeapSort:%d\n", end4_1 - begin4_1);
printf("BubbleSort:%d\n", end5 - begin5);
printf("QuickSort:%d\n", end6 - begin6);
printf("QuickSort:%d\n", end6_1 - begin6_1);
free(a1);
free(a2);
free(a3);
free(a4);
free(a5);
free(a6);
}
//测试插入排序
void TestInsertSort() {
int a[] = { 1,5,3,7,0,9 };
InsertSort(a, sizeof(a) / sizeof(a[0]));
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
//测试希尔排序
void TestShellSort() {
int a[] = { 9,1,2,5,7,4,8,6,3,5 };
ShellSort(a, sizeof(a) / sizeof(a[0]));
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
//测试选择排序
void TestSelectSort() {
int a[] = { 9,1,2,5,7,4,8,6,3,5 };
SelectSort(a, sizeof(a) / sizeof(a[0]));
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
//测试堆排序
void TestHeapSort() {
int a[] = { 9,1,2,5,7,4,8,6,3,5 };
HeapSort(a, sizeof(a) / sizeof(a[0]));
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
//测试冒泡排序
void TestBubbleSort() {
int a[] = { 9,1,2,5,7,4,8,6,3,5 };
BubbleSort(a, sizeof(a) / sizeof(a[0]));
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
//测试单趟排序
void TestPartSort1() {
int a[] = { 5,5,5,5,5,5,5,5,5,5 };
PartSort1(a,0 ,sizeof(a) / sizeof(a[0])-1);
PrintArray(a, sizeof(a) / sizeof(a[0]));
}
int main(){
//TestInsertSort();
//TestShellSort();
//TestSelectSort();
//TestHeapSort();
//TestBubbleSort();
//TestPartSort1();
//TestQuickSort();
TestQuickSortNonR();
//TestOP();
return 0;
}
