【本节目标】
1.
排序的概念及其运用
2.
常见排序算法的实现
3.
排序算法复杂度及稳定性分析
1.排序的概念及其运用
1.1排序的概念
排序
：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性
：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中，
r[i]=r[j]
，且
r[i]
在
r[j]
之前，而在排序后的序列中，
r[i]
仍在
r[j]
之前，则称这种排
序算法是稳定的；否则称为不稳定的
稳定性
：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中，
r[i]=r[j]
，且
r[i]
在
r[j]
之前，而在排序后的序列中，
r[i]
仍在
r[j]
之前，则称这种排
序算法是稳定的；否则称为不稳定的
1.2排序运用
1.3 常见的排序算法
// 排序实现的接口
// 插入排序
void InsertSort(int* a, int n);
// 希尔排序
、void ShellSort(int* a, int n);
// 选择排序
void SelectSort(int* a, int n);
// 堆排序
void AdjustDwon(int* a, int n, int root);
void HeapSort(int* a, int n);
// 冒泡排序
void BubbleSort(int* a, int n)
// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right);
// 快速排序挖坑法
int PartSort2(int* a, int left, int right);
// 快速排序前后指针法
int PartSort3(int* a, int left, int right);
void QuickSort(int* a, int left, int right);
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
// 归并排序递归实现
void MergeSort(int* a, int n)
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
// 计数排序
void CountSort(int* a, int n)
// 测试排序的性能对比
void TestOP()
{
srand(time(0));
const int N = 100000;
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 begin5 = clock();
QuickSort(a5, 0, N-1);
int end5 = clock();
int begin6 = clock();
MergeSort(a6, N);
int end6 = 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("QuickSort:%d\n", end5 - begin5);
printf("MergeSort:%d\n", end6 - begin6);
free(a1);
free(a2);
free(a3);
free(a4);
free(a5);
free(a6);
}排序OJ(可使用各种排序跑这个OJ)912. 排序数组 - 力扣（LeetCode）
2.常见排序算法的实现
2.1 插入排序
2.1.1基本思想：
直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为
止，得到一个新的有序序列
。
实际中我们玩扑克牌时，就用了插入排序的思想
2.1.2直接插入排序：
当插入第
i(i>=1)
个元素时，前面的
array[0],array[1],…,array[i-1]
已经排好序，此时用
array[i]
的排序码与
array[i-1],array[i-2],…
的排序码顺序进行比较，找到插入位置即将
array[i]
插入，原来位置上的元素顺序后移
直接插入排序的特性总结：
1.
元素集合越接近有序，直接插入排序算法的时间效率越高
2.
时间复杂度：
O(N^2)
3.
空间复杂度：
O(N)
，它是一种稳定的排序算法
4.
稳定性：稳定
代码实现：
void InsertSort(int* arr, int length)
{
for (int i = 0; i < length-1; i++)
{
int end=i;
int temp = arr[end + 1];
while (end >= 0)
{
if (temp < arr[end])
{
arr[end+1] = arr[end];
}
else
{
break;
}
end--;
}
arr[end + 1] = temp;
}
}2.1.3希尔排序
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达gap=1时，所有记录在统一组内排好序
希尔排序的特性总结：
1.
希尔排序是对直接插入排序的优化。
2.
当
gap > 1
时都是预排序，目的是让数组更接近于有序。当
gap == 1
时，数组已经接近有序的了，这样就
会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3.
希尔排序的时间复杂度不好计算，因为
gap
的取值方法很多，导致很难去计算，因此在好些树中给出的
希尔排序的时间复杂度都不固定
时间复杂度可以即一个结论大概是：N^1.3
代码实现：
void SellSort(int* arr, int length)
{
int gap = length;
while (gap>1)
{
gap = gap / 3 + 1;
for (int i = 0; i < length-gap; i++)
{
int end = i;
int temp = arr[end + gap];
while (end>=0)
{
if (temp < arr[end])
{
arr[end + gap] = arr[end];
end = end - gap;
}
else
{
break;
}
}
arr[end + gap] = temp;
}
}
}
2.2冒泡排序
基本思路：
左边大于右边交换一趟排下来最大的在右边
冒泡排序的特点包括：
1. 冒泡排序适合处理元素集合越接近有序的情况，时间效率会更高。
2. 冒泡排序的时间复杂度为O(N^2)，性能较差，不适用于处理大规模数据的排序。
3. 冒泡排序是一种稳定的排序算法，相同元素的相对位置不会发生改变。
4. 冒泡排序的空间复杂度为O(N)，是一种原地排序算法。
5. 冒泡排序是一种交换排序算法，通过不断比较相邻的元素并交换位置来达到排序的目的。
代码实现：
void BubbleSort(int* arr, int length)
{
for (int i = 0; i < length-1; i++)
{
int flag = 0;
for (int j = 0; j < length-i-1; j++)
{
if (arr[j] > arr[j + 1])
{
Swap(&arr[j], &arr[j + 1]);
flag = 1;
}
}
if (flag == 0)
{
break;
}
}
}2.3堆排序
堆排序是一种基于二叉堆数据结构的排序算法，其基本思路如下：
-
构建最大堆或最小堆：将待排序的数组视作一个完全二叉树，并且通过调整父节点与子节点的关系，使得每个父节点的值都大于或小于其子节点的值，即构建最大堆或最小堆。
-
将堆顶元素与最后一个元素交换：将根节点（最大值或最小值）与最后一个元素交换位置。
-
调整堆结构：交换元素后，调整堆结构，使其重新满足最大堆或最小堆的性质。
-
重复步骤2和3：重复进行上述步骤，直到所有元素都被交换到对应的位置，即完成排序。
堆排序的时间复杂度为O(nlogn)，其中n为待排序数组的长度。堆排序是一种原地排序算法，不需要额外的空间，但性能较差且不稳定。
代码实现：
void AdjustDown(int* arr,int length, int parent)
{
int child = parent * 2 + 1;
while (child<length)
{
if (child+1<length && arr[child + 1] > arr[child])
{
child++;
}
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = child * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* arr, int length)
{
for (int i = (length-1-1)/2; i >= 0; i--)
{
AdjustDown(arr, length, i);
}
int end = length - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, end, 0);
end--;
}
}2.4选择排序
基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的
数据元素排完 。
代码实现:
void SelectSort(int* arr, int length)
{
int begin = 0, end = length - 1;
while (begin <end)
{
int max_index = begin;
int min_index = begin;
for (size_t i = begin+1; i <=end; i++)
{
if (arr[i] > arr[max_index])
{
max_index = i;
}
if (arr[i] < arr[min_index])
{
min_index = i;
}
}
Swap(&arr[min_index], &arr[begin]);
if (max_index == begin)
{
max_index=min_index;
}
Swap(&arr[max_index], &arr[end]);
begin++;
end--;
}
}2.5快速排序
快速排序是
Hoare
于
1962
年提出的一种二叉树结构的交换排序方法，其基本思想为：
任取待排序元素序列中
的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右
子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止
。
普通版
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
{
return;
}
int begin = left;
int end = right;
int key_index = left;
while (left<right)
{
while (left<right && arr[right]>=arr[key_index])
{
right--;
}
while (left < right && arr[left]<=arr[key_index])
{
left++;
}
Swap(&arr[left], &arr[right]);
}
Swap(&arr[left], &arr[key_index]);
key_index = left;
QuickSort(arr, begin, key_index - 1);
QuickSort(arr, key_index + 1, end);
}如果数据是随机的那么快排的时间复杂度就是n logn ，如果是有序的数据或者接近有序的那么快排的时间复杂度就是n^2 所以key可以采用随机选取的方式
随机key
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
{
return;
}
int randi = rand() % (right - left+1) + left;
Swap(&arr[left], &arr[randi]);
int begin = left;
int end = right;
int key_index = left;
while (left<right)
{
while (left<right && arr[right]>=arr[key_index])
{
right--;
}
while (left < right && arr[left]<=arr[key_index])
{
left++;
}
Swap(&arr[left], &arr[right]);
}
Swap(&arr[left], &arr[key_index]);
key_index = left;
QuickSort(arr, begin, key_index - 1);
QuickSort(arr, key_index + 1, end);
}三数取中法
int GetMid(int* arr, int left, int right)
{
int mid = (left + right) / 2;
if (arr[left] < arr[mid])
{
if (arr[mid] < arr[right])
{
return mid;
}
else if(arr[left] > arr[right])
{
return left;
}
else
{
return right;
}
}
else if(arr[left] > arr[mid])
{
if (arr[mid] > arr[right])
{
return mid;
}
else if(arr[left] < arr[right])
{
return left;
}
else
{
return right;
}
}
}
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
{
return;
}
int begin = left;
int end = right;
int mid_index = GetMid(arr, left, right);
Swap(&arr[left], &arr[mid_index]);
int key_index = left;
while (left<right)
{
while (left<right && arr[right]>=arr[key_index])
{
right--;
}
while (left < right && arr[left]<=arr[key_index])
{
left++;
}
Swap(&arr[left], &arr[right]);
}
Swap(&arr[left], &arr[key_index]);
key_index = left;
QuickSort(arr, begin, key_index - 1);
QuickSort(arr, key_index + 1, end);
}双指针法
void QuickSort(int* arr, int left, int right)
{
if (left > right)
{
return;
}
int prev = left, cur = left + 1;
int key_index = left;
while (cur<=right)
{
if (arr[cur] <= arr[key_index] && ++prev!=cur)
{
Swap(&arr[cur], &arr[prev]);
}
cur++;
}
Swap(&arr[key_index], &arr[prev]);
key_index = prev;
QuickSort(arr, left, key_index - 1);
QuickSort(arr, key_index+1,right);
}非递归
void QuickSortNonR(int* arr, int left, int right)
{
ST st;
STInit(&st);
STPush(&st, right);
STPush(&st, left);
while (!STEmpty(&st))
{
int begin = STTop(&st);
STPop(&st);
int end = STTop(&st);
int key_index = begin;
int prev =begin ;
int cur = begin + 1;
while (cur<=end)
{
if (arr[cur] < arr[key_index] && ++prev !=cur)
{
Swap(&arr[cur], &arr[prev]);
}
cur++;
}
Swap(&arr[prev], &arr[key_index]);
key_index = prev;
if (key_index + 1 < end)
{
STPush(&st, end);
STPush(&st, key_index + 1);
}
if (begin +1 < key_index )
{
STPush(&st, key_index - 1);
STPush(&st, begin);
}
}
STDestory(&st);
}2.6归并排序
void _MergeSort(int* arr, int begin, int end,int* temp)
{
if (begin==end)
{
return;
}
int mid = (begin + end) / 2;
_MergeSort(arr, 0, mid,temp);
_MergeSort(arr, mid+1, end,temp);
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
while (begin1<=end1 && begin2<=end2)
{
if (arr[begin1] < arr[begin2])
{
temp[i++] = arr[begin1++];
}
else
{
temp[i++] = arr[begin2++];
}
}
while (begin1 <= end1)
{
temp[i++] = arr[begin1++];
}
while (begin2 <= end2)
{
temp[i++] = arr[begin2++];
}
memcpy(arr + begin, temp + begin, sizeof(int)*(end - begin + 1));
}
void MergeSort(int* arr, int length)
{
int* temp = (int*)malloc(sizeof(int) * length);
if (temp == NULL)
{
perror("malloc fail!");
exit(1);
}
_MergeSort( arr, 0, length-1 ,temp);
}非递归
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
int gap = 1;
while (gap < n)
{
//printf("gap:%d->", gap);
for (int j = 0; j < n; j += 2 * gap)
{
int begin1 = j, end1 = begin1 + gap - 1;
int begin2 = begin1 + gap, end2 = begin2 + gap - 1;
//printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);
// 越界的问题处理
if (end1 >= n || begin2 >= n)
break;
if (end2 >= n)
end2 = n - 1;
int i = j;
// 依次比较，取小的尾插tmp数组
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));
}
//printf("\n");
gap *= 2;
}
free(tmp);
tmp = NULL;
}
2.7计数排序
void CountSort(int* arr, int length)
{
int max = arr[0], min = arr[0];
for (int i = 1; i < length; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
if (arr[i] < min)
{
min = arr[i];
}
}
int range = max - min + 1;
int* count = (int*)malloc(sizeof(int) * range);
if (count == NULL)
{
perror("malloc fail!");
exit(1);
}
memset(count, 0, sizeof(int)* range);
for (int i = 0; i < length; i++)
{
count[arr[i] - min]++;
}
int index = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
arr[index++] = i + min;
}
}
}
606
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
