目录
数据结构八大排序
1.直接插入排序
特性：
1️⃣数据越接近有序，直接插入排序算法效率越高。
2️⃣最坏时间复杂度:O(N^2)
3️⃣最好时间复杂度：O(N)。
4️⃣空间复杂度：O(1)
5️⃣稳定性：稳定
将第一个和第二个元素排好序，然后将第3个元素插入到已经排好序的元素中，依次类推（插入排序最好的情况就是数组已经有序了）
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; ++i)
{
//i = 0，tmp是它的下一个
int end = i;
int tmp = a[end + 1];
while (end >= 0)
{
if (tmp < a[end])//升序
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
2.希尔排序
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
特性：
1️⃣平均时间复杂度：O(N^1.3)
2️⃣空间复杂度：O(1)
3️⃣稳定性：不稳定
4️⃣最好时间复杂度：O(N)
5️⃣最坏时间复杂度：O(N2)
那为什么要让gap以从大到小这样的方式进行排序呢？
1️⃣gap越大，大的数可以更快的到后面，小的数可以更快的到前面，越不接近有序。当gap=5时，9会一下跳5个数，可以快速的跳到后面。我们现在用的10个数不明显，如果是100万个数呢？
2️⃣gap越小，数据跳动的越慢，越接近有序。当gap=1时，只需要进行一次直接插入排序就能得到最终结果
void ShellSort(int* a, int n)
{
int gap = n;
while (gap>1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
3.选择排序
每一次从待排序的数据中选出最小和最大的元素，放在起始位置和末尾，直到将全部待排序的数据元素排完
思路：mini找最小的元素，maxi找最大的元素，然后将最大的元素放到end的位置，最小的元素放到begin的位置
特性：
1️⃣最好时间复杂度：O(N2)
2️⃣空间复杂度：O(1)
3️⃣稳定性：不稳定
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
int mini = begin;
int maxi = begin;
while (begin < end)
{
for (int i = begin + 1; 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)//防止第一个元素最大时重复交换
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
}
4.堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排 升序要建大堆，降序建小堆
1️⃣时间复杂度为O(N*log2N);
2️⃣空间复杂度为O(1);
**思路：**我们升序建的是大堆，待会把堆建好以后，我们把堆顶的数和最后一个数交换，然后向下调整。
void AdjustDwon(int* a, int n, int root)
{
int child = root * 2 + 1;
while (child < n)
{
//找出左右孩子中较大的那一个
if (child + 1 < n && a[child+1] > a[child])
{
child++;
}
if (a[child] > a[root])
{
Swap(&a[child], &a[root]);
root = child;
child = root * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
//建堆算法
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDwon(a, n, i);
}
int end = n - 1;
while (end)
{
//交换
Swap(&a[0], &a[end]);
AdjustDwon(a,end,0);
--end;
}
}
5.冒泡排序
冒泡排序就不用多说了吧。两层循环，相邻的两个数进行比较，一趟下来最大的在最右边
进行的是n-1趟之后，便就排序好
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
int flag = 0;
for (int j = i; j < n - i; j++)
{
if (a[j - 1]>a[j])
{
Swap(&a[j - 1], &a[j]);
flag = 1;
}
}
//如果flag==0，没有发生交换，证明这一段有序，不需要在走。
if (flag == 0)
{
break;
}
}
}
6.快速排序
6.1快速排序hoare版本
思路：
1.我们先把第一个数当key
2.然后让右边先走，找比key小的数
3.左边走，找比key大的数
4.左右相遇交换当前位置left和key的值
走完之后会形成两个区间：【begin ，key-1】key【key+1，end】
🐲排完之后key的左边全是比它小的，右边全是比他大的。这只是一趟，我们还要进行递归
int PartSort1(int* a, int begin, int end)
{
//如果区间不存在就直接返回
if (begin >= end)
{
return;
}
int left = begin;
int right = end;
int keyi = left;
while (left < right)
{
//一定让右边先走,找到比keyi小的跳出循环
while (left < right && a[right] >= a[keyi])
{
right--;
}
//找到比keyi大的跳出
while (left < right && a[left] <= a[keyi])
{
left++;
}
//交换，让左边都是比keyi小，右边都比keyi大
Swap(&a[left],&a[right]);
}
//交换keyi和最后相遇的位置
Swap(&a[left], &a[keyi]);
keyi = left;
PartSort1(a, begin, keyi - 1);
PartSort1(a, keyi + 1, end);
return keyi;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
return;
//
int key = PartSort1(a, begin, end);
QuickSort(a, begin, key - 1);
QuickSort(a, key + 1, end);
}
6.2挖坑法
思路：还是右边找小，左边找大，只不过把交换变成了坑位
int PartSort2(int* a, int begin, int end)
{
//如果区间不存在就直接返回
int left = begin;
int right = end;
int key = a[left];//保存基准值
int hole = left;//坑位
while (left < right)
{
//找小
while (left < right && a[right] >= key)
{
right--;
}
//放坑位
if (left < right)
{
a[hole] = a[right];
hole = right;//更新坑位
}
//找大
while (left < right && a[left] <= key)
{
left++;
}
if (left < right)
{
a[hole] = a[left];
hole = left;
}
}
a[hole] = key;
return hole;
}
6.3快速排序前后指针法
int PartSort3(int* a, int begin, int end)
{
int key = begin;
int prev = begin;
int cur = begin + 1;
while (cur <= end)
{
if (a[cur] < a[key] && ++prev != cur)//注意先++prev在比较
{
Swap(&a[prev],&a[cur]);
}
cur++;
}
Swap(&a[key], &a[prev]);
key = prev;
return key;
}
6.4快速排序非递归
递归的算法主要是在划分子区间，如果要非递归实现快排，只要使用一个栈来保存区间就可以了。一般将递归程序改成非递归首先想到的就是使用栈，因为递归本身就是一个压栈的过程。
非递归的基本思想：
1️⃣申请一个栈，存放排序数组的起始位置和终点位置。
2️⃣将整个数组的起始位置和终点位置入栈。
3️⃣由于栈的特性是：后进先出，right后进栈，所以right先出栈。 定义一个end接收栈顶元素，出栈操作、定义一个begin接收栈顶元素，出栈操作。
4️⃣对数组进行一次单趟排序，返回key关键值的下标。
5️⃣这时候需要排基准值key左边的序列。如果只将基准值key左边序列的起始位置和终点位置存入栈中，等左边排序完将找不到后边的区间。所以先将右边序列的起始位置和终点位置存入栈中，再将左边的起始位置和终点位置后存入栈中。
6️⃣判断栈是否为空，若不为空 重复4、5步、若为空则排序完成。
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);
//[left, keyi-1] keyi [keyi+1, right]
//先入后出，先入右区间，保证只有一个数，有两个数以上的时候才需要入栈
if (keyi + 1 < right)
{
StackPush(&st, keyi + 1);
StackPush(&st, right);
}
if (left < keyi - 1)
{
StackPush(&st, left); //新的右边界，入栈
StackPush(&st, keyi - 1);//新的左边界，入栈
}
}
StackDestroy(&st);
}
快速排序的总结：
1️⃣快排的整体综合性能和使用场景都是比较好的，所以才敢叫快速排序
2️⃣快排唯一死穴，就是排一些有序或者接近有序的序列，例如 2,3,2,3,2,3,2,3这样的序列时，会变成O(N^2)的时间复杂度
3️⃣时间复杂度O(N*logN)
4️⃣空间复杂度O(logN)
7.归并排序
7.1递归归并
1.归并排序的缺点是需要O(N)的空间复杂度；
2.时间复杂度：O(N*logN);
3.稳定性：稳定
思路：
将一个大区间的数据分成若干个小区间的数据进行排序，采用先分解后合并的方法进行排序；首先递归分解左区间直到剩余一个数据的时候默认有序，然后递归右区间，有两个数据的时候（升序）比较取小的数据尾插到开辟好的空间，然后拷贝到原数组中。
void _MergeSort(int* a, int left, int right, int* tmp)
{
if (left >= right)
{
return;
}
int mid = (left + right) / 2;
_MergeSort(a, left, mid, tmp);
_MergeSort(a, mid+1, right, tmp);
int begin1 = left, end1 = mid;
int begin2 = mid + 1, end2 = right;
int i = left;
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++];
}
for (int j = left; j <= right; j++)
{
a[j] = tmp[j];
}
}
//归并排序
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int)*n);
if (tmp == NULL)
{
printf("malloc fail\n");
exit(-1);
}
_MergeSort(a,0,n-1,tmp);
free(tmp);
tmp = NULL;
}
7.2非递归归并
！！！一定要注意，非递归归并区间一定要看清楚。
我们知道，递归实现的缺点就是会一直调用栈，而栈内存往往是很小的。所以，我们尝试着用循环的办法去实现
由于我们操纵的是数组的下标，所以我们需要借助数组，来帮我们存储上面递归得到的数组下标，和递归的区别就是，递归要将区间一直细分，要将左区间一直递归划分完了，再递归划分右区间，而借助数组的非递归是一次性就将数据处理完毕，并且每次都将下标拷贝回原数组。
存在的问题：当数据个数不是2^n个的时候就会存在越界访问的情况！
存在越界的三种情况：
1️⃣第一组right1越界
2️⃣第二组部分越界
3️⃣第三组全部越界
**改正思路：**当遇到越界访问的时候就跳出循环，并且避免整齐拷贝的时候对于跳出循环漏掉数据，则采用归并一个数据就拷贝一个数据
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int)*n);
if (tmp == NULL)
{
printf("malloc fail\n");
exit(-1);
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
// [i,i+gap-1] [i+gap,i+2*gap-1]
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
// 核心思想：end1、begin2、end2都有可能越界
// end1越界 或者 begin2 越界都不需要归并
if (end1 >= n || begin2 >= n)
{
break;
}
// end2 越界，需要归并，修正end2
if (end2 >= n)
{
end2 = n- 1;
}
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 把归并小区间拷贝回原数组
for (int j = i; j <= end2; ++j)
{
a[j] = tmp[j];
}
}
gap *= 2;
}
free(tmp);
tmp = NULL;
}
8.计数排序
1、在数据范围比较集中时，效率很高，但是使用场景很有限，可以排负数，但对于浮点数无能为力
2、时间复杂度：O(MAX(N,range))
3、空间复杂度：O(range)
实现思路： 1.统计相同元素出现的次数;2.根据统计的次数对数据进行排序
实现方法： 采用相对映射的方法
1.开辟max-min+1的空间大小；
2.a[i]-min就是相对映射的位置
void CountSort(int* a, int n)
{
int min = a[0], max = a[0];//如果不赋值，min和max就是默认随机值，最好给赋值一个a[0]
for (int i=1;i<n;i++)//修正 找出A数组中的最大值和最小值
{
if (a[i] < min)
{
min=a[i];
}
if (a[i]>max)
{
max=a[i];
}
}
int range = max - min + 1;//控制新开数组的大小，以免空间浪费
int* count = (int*)malloc(sizeof(int) * range);
memset(count,0, sizeof(int) * range);//初始化为全0
if (count==NULL)
{
printf("malloc fail\n");
exit(-1);
}
//1、统计数据个数
for (int i=0;i<n;i++)
{
count[a[i]-min]++;
}
//2、拷贝回A数组
int j = 0;
for (int i=0;i<range;i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
free(count);
count = NULL;
}
总结：
稳定的排序有：直接插入排序、冒泡排序、归并排序
不稳定的排序有：希尔排序、选择排序、堆排序、快速排序、计数排序
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
