|
一.排序
(1)排序的概念 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
二.插入排序+希尔排序
1.插入排序基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
2.插入排序的特性：
(1). 元素集合越接近有序，直接插入排序算法的时间效率越高。
(2). 时间复杂度：O(N^2)。
(3). 空间复杂度：O(1)，它是一种稳定的排序算法。
(4). 稳定性：稳定。
3.希尔排序基本思想：希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达=1时，所有记录在统一组内排好序。
4.希尔排序的特性：
(1). 希尔排序是对直接插入排序的优化。
(2). 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
(3). 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定：
5.实现：插入排序+希尔排序
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 插入排序
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int lin = i;
int tmp = a[lin + 1];
while (lin >= 0)
{
if (tmp < a[lin])
{
a[lin + 1] = a[lin];
lin--;
}
else
{
break;
}
}
a[lin + 1] = tmp;
}
}
// 希尔排序
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 lin = i;
int tmp = a[lin + gap];
while (lin >= 0)
{
if (tmp < a[lin])
{
a[lin + gap] = a[lin];
lin -= gap;
}
else
{
break;
}
}
a[lin + gap] = tmp;
}
}
}
void print(int* a,int sz)
{
for (int i = 0; i < sz; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[] = { 3,2,4,1 };
int sz1 = sizeof(a) / sizeof(a[0]);
InsertSort(a, sz1);
print(a, sz1);
int w[] = { 3,2,4,1};
int sz2 = sizeof(w) / sizeof(w[0]);
ShellSort(w, sz2);
print(w, sz2);
return 0;
}
三：选择排序+堆排序
1.选择排序基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完 。
在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
2.选择排序的特性： 直接选择排序思考非常好理解，但是效率不是很好。
(1). 时间复杂度：O(N^2)
(2). 空间复杂度：O(1)
(3). 稳定性：不稳定
3.堆排序基本思想：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
4.堆排序的特性：
(1). 堆排序使用堆来选数，效率就高了很多。
(2). 时间复杂度：O(N*logN)
(3). 空间复杂度：O(1)
(4). 稳定性：不稳定
5.实现：选择排序+堆排序
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//交换数据
void Swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
// 选择排序
void SelectSort(int* a, int n)
{
assert(a);
int lin = 0, end = n - 1;
while (lin < end)
{
int min = lin, max = lin;
for (int i = lin + 1; i <= end; i++)
{
if (a[i] < a[min])
{
min = i;
}
if (a[i] > a[max])
{
max = i;
}
}
Swap(&a[lin], &a[min]);
//lin与max重叠
if (lin == max)
{
max = min;
}
Swap(&a[end], &a[max]);
lin++;
end--;
}
}
// 堆排序
//向下调整函数
void AdjustDown(int* a, size_t size, size_t root)
{
assert(a);
int parent = root;
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && a[child + 1] < a[child])
{
++child;
}
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
// 对数组进行堆排序
void HeapSort(int* a, int n)
{
assert(a);
for (int i = (n - 1) / 2; i >= 0; i--) //从最后叶节点的父节点开始调整
{
AdjustDown(a, n, i);
}
}
//打印函数
void HeapPrint(int* a, size_t n)
{
assert(a);
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[] = { 3,2,4,1 };
int sz = sizeof(a) / sizeof(a[0]);
SelectSort(a, sz);
HeapPrint(a, sz);
return 0;
}
四：冒泡排序+快速排序
1.冒泡排序基本思想：就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，冒泡排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
2.冒泡排序的特性：
(1). 冒泡排序是一种非常容易理解的排序
(2). 时间复杂度：O(N^2)
(3). 空间复杂度：O(1)
(4). 稳定性：稳定
3.快速排序基本思想：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
4.快速排序的特性：
(1). 快速排序整体的综合性能和使用场景都是比较好的
(2). 时间复杂度：O(N*logN)
(3). 空间复杂度：O(logN)
(4). 稳定性：不稳定
5.实现：冒泡排序+快速排序
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//交换数据
void Swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
// 冒泡排序
void BubbleSort(int* a, int n)
{
assert(a);
int lin = 0;
for (int i = 0; i < n; i++)
{
for (int j = 1; j < j - i; j++)
{
int lin = 1;
if (a[j-1] > a[j])
{
Swap(&a[j - 1], &a[j]);
}
}
if (lin == 0)
{
break;
}
}
}
int GetMidIndex(int* a, int begin, int end)
{
int midi = begin + (end - begin) / 2;
if (a[begin] < a[midi])
{
if (a[midi] < a[end])
{
return midi;
}
else if (a[begin] < a[end])
{
return end;
}
else
{
return begin;
}
}
else //a[begin]>a[midi]
{
if (a[midi] > a[end])
{
return midi;
}
else if (a[begin] > a[end])
{
return end;
}
else
{
return begin;
}
}
}
// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
int left = begin, right = end;
int keyi = left;
//三数取中
int midi = GetMidIndex(a, begin, end);
Swap(&a[keyi], &a[midi]);
while (left < right)
{
//右边先走，找小
while (left < right && a[right] >= a[keyi])
{
right--;
}
//左边在走，找大
while (left < right && a[left] <= a[keyi])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[keyi], &a[left]);
keyi = left;
PartSort1(a, begin,keyi - 1);
PartSort1(a, keyi + 1, end);
}
// 快速排序挖坑法
int PartSort2(int* a, int begin, int end)
{
if (begin >=end)
{
return;
}
int left = begin, right = end;
int keyi = a[begin];
//记录坑的下标
int piti = begin;
//三数取中
int midi = GetMidIndex(a, begin, end);
Swap(&keyi, &a[midi]);
while (left < right)
{
//右边找小
while (left < right && a[right] >= keyi)
{
right--;
}
a[piti] = a[right];
piti = right;
//左边找大
while (left < right && a[left] <= keyi)
{
left++;
}
a[piti] = a[left];
piti = left;
}
//最后相遇
a[piti] = keyi;
piti = left;
PartSort2(a, begin, piti-1);
PartSort2(a, piti+1, end);
}
// 快速排序前后指针法
int PartSort3(int* a, int begin, int end)
{
int prev = begin;
int cur = begin + 1;
int keyi = begin;
//三数取中
int midi = GetMidIndex(a, begin, end);
Swap(&a[keyi], &a[midi]);
while (cur <= end)
{
if (a[cur] < a[keyi] && ++prev != cur)
{
Swap(&a[cur], &a[prev]);
}
cur++;
}
Swap(&a[prev], &a[keyi]);
keyi = prev;
return keyi;
}
// 插入排序
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int lin = i;
int tmp = a[lin + 1];
while (lin >= 0)
{
if (tmp < a[lin])
{
a[lin + 1] = a[lin];
lin--;
}
else
{
break;
}
}
a[lin + 1] = tmp;
}
}
void QuickSort(int* a, int begin, int end)
{
if (begin >=end)
{
return;
}
if (end - begin > 10)
{
int keyi = PartSort3(a, begin, end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
else
{
InsertSort(a + begin, end - begin + 1);
}
}
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
//栈模拟
ST st;
StackInit(&st);
//后进先出
StackPush(&st,end);
StackPush(&st,begin);
while (StackEmpty(&st)
{
int left= StackTop(&st);
StackPop(&st);
int right= StackTop(&st);
StackPop(&st);
int keyi = Partsort3(a, left, right);
//范围[left,keyi-1] keyi [keyi+1,right]
if (left < keyi - 1)
{
//先入右在入左
StackPush(&st,keyi-1);
StackPush(&st, left);
}
if (keyi + 1< right)
{
//先入右在入左
StackPush(&st, right);
StackPush(&st, keyi + 1);
}
}
}
//打印
void Print(int* a, size_t n)
{
assert(a);
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[] = { 3,5,2,6,8,9,6 ,1 };
int w[] = { 4,5,2,7,8,9,5,10 };
int h[] = { 2,4,2,5,8,5,9,4, };
int sz1 = sizeof(a) / sizeof(a[0]);
int sz2 = sizeof(w) / sizeof(w[0]);
int sz3 = sizeof(h) / sizeof(h[0]);
PartSort1(a, 0, sz1 - 1);
PartSort2(w, 0, sz2 - 1);
QuickSort(h, 0, sz3 - 1);
Print(a, sz1);
Print(w, sz2);
Print(h, sz2);
return 0;
}
五：归并排序+计数排序
1.归并排序基本思想：建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
2.归并排序的特性：
(1). 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
(2). 时间复杂度：O(N*logN)
(3). 空间复杂度：O(N)
(4). 稳定性：稳定
3.计数排序基本思想：
(1). 统计相同元素出现次数
(2). 根据统计的结果将序列回收到原来的序列中
4.计数排序的特性：
(1). 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
(2). 时间复杂度：O(MAX(N,范围))
(3). 空间复杂度：O(范围)
(4). 稳定性：稳定
5.实现:归并排序+计数排序
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
void lin(int* a, int begin, int end, int* tmp)
{
if (begin >= end)
{
return;
}
int mid = begin + (end - begin) / 2;
//区间[begin,mid],[mid+1,end]
lin(a, begin, mid, tmp);
lin(a, mid+1, end, tmp);
//归并
int left1 = begin, right1 = mid;
int left2 = mid + 1, right2 = end;
int i = left1;
while (left1 <= right1 && left2 <= right2)
{
if (a[left1] < a[left2])
{
tmp[i++] = a[left1++];
}
else
{
tmp[i++] = a[left2++];
}
}
//将最后一个数存放至tmp中
while (left1 <= right1)
{
tmp[i++] = a[left1++];
}
while (left2 <= right2)
{
tmp[i++] = a[left2++];
}
//将归并好的数据拷贝回原数据
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
int* tmp=(int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
printf("MALLOC:");
exit(-1);
}
lin(a, 0, n - 1, tmp);
free(tmp);
}
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
printf("MALLOC:");
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越界
if (end1 >= n || begin2 >= n)
{
break;
}
else if(end2>=n)
{
end2 = n - 1;
}
int m = end2 - begin1+ 1;
int j = begin1;
while (begin1 <=end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
//将最后一个数存放至tmp中
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
//将归并好的数据拷贝回原数据
memcpy(a +i, tmp + i, m * sizeof(int));
}
gap *= 2;
}
free(tmp);
}
// 计数排序
void CountSort(int* a, int n)
{
int min = a[0], max = a[0];
//找出最大
for (int i = 0; i < n; i++)
{
if (a[i] < min)
{
min = a[0];
}
if (a[i] > max)
{
max = a[i];
}
}
//创建一个统计次数的数组
int count = max - min + 1;
int* tmp = (int*)malloc(sizeof(int) * count);
if (tmp == NULL)
{
printf("MALLOC:");
exit(-1);
}
memset(tmp, 0, sizeof(int) * count);
//统计次数
for (int i = 0; i < n; i++)
{
tmp[a[i] - min]++;
}
//回写排序
int j = 0;
for (int i = 0; i < count; i++)
{
while (tmp[i]--)
{
a[j++] = i + min;
}
}
}
void print(int* a, int sz)
{
for (int i = 0; i < sz; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[] = {2,5,8,9,3,5,10,6,7 };
int b[] = { 3,6,8,2,4,7,9,5,4 };
int c[] = { 6,4,8,3,2,6,7,8,5 };
int sz1 = sizeof(a) / sizeof(a[0]);
int sz2 = sizeof(b) / sizeof(b[0]);
int sz3 = sizeof(c) / sizeof(c[0]);
// 归并排序递归实现
MergeSort(a, sz1);
print(a, sz1);
// 归并排序非递归实现
MergeSortNonR(b, sz2);
print(b, sz2);
//计数排序
CountSort(c, sz3);
print(a, sz1);
return 0;
}
|