目录
1、插入排序
1.1、直接插入排序
基本思想：把待排序的元素按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的元素插入完为止，得到一个新的有序序列 。当插入第i(i>=1)个，前a[0]、a[1]、a[2]、……a[i-1]个元素已经排好序，这时候用第i个元素的关键字与a[i-1]、a[i-2]……的关键词一次比较，当找到位置时将a[i]插入，将原来位置上的元素依次后移。当元素接近有序时，由于元素后移次数减少，所以时间减少，所以当元素越接近有序时间效率越高。
过程图示：动画阐释各种排序算法（之前误删了大家也不用再点赞投币了）_哔哩哔哩_bilibili
代码：
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int tmp = a[i + 1];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}1.2、希尔排序
基本思想：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=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;
}
}
}2、选择排序
基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
2.1、直接选择排序
基本思想：
在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素，若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
代码：
//一次选出最大最小
void SelectSort(int* a, int n)
{
int left = 0, right = n - 1;
while (left < right)
{
int mini = left, maxi = left;
for (int i = left + 1; i <= right; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
Swap(&a[left], &a[mini]);
if (left == maxi)
{
maxi = mini;
}
Swap(&a[right], &a[maxi]);
left++;
right--;
}
}2.2、堆排序
基本思想：通过堆选择元素的关键词，注意升序要建大堆，降序要建小堆
代码：
void AdjustDwon(int* a, int n, int root)//向下调整建堆
{
int parent = root;
int chlid = root * 2 + 1;
while (chlid < n)
{
if (chlid + 1 < n && a[chlid + 1] < a[chlid])
{
chlid++;
}
if (a[parent] > a[chlid])
{
Swap(&a[parent], &a[chlid]);
parent = chlid;
chlid = parent * 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 > 0)
{
Swap(&a[0], &a[end]);
AdjustDwon(a, end, 0);
end--;
}
}3、交换排序
基本思想：
所谓交换，就是根据序列中两个元素关键词的比较结果来对换这两个元素在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
3.1、冒泡排序
基本思想：每一趟都会将最大或最小的元素归位到相应的位置，像气泡一样第一次冒出最大的，第二次第二大，直到结束
代码：
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])
{
exchange = 1;
Swap(&a[j - 1], &a[j]);
}
}
if (exchange == 0)
{
return;
}
}
}3.2、快速排序
基本思想：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。但当要排序的序列接近有序时算法的时间复杂度会急剧增大，采取三数取中法优化
代码：
三数取中法
int GetMidIndex(int* a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
else
{
if (a[right] > a[mid])
{
return mid;
}
else if (a[left] > a[right])
{
return left;
}
else
{
return right;
}
}
}3.2.1、hoare法
int PartSort1(int* a, int left, int right)
{
int midi = GetMidIndex(a, left, right);
Swap(&a[left], &a[midi]);
int key = left;
while (left < right)
{
while (left < right && a[right] >= a[key])
{
right--;
}
while (left < right && a[left] <= a[key])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[key]);
return left;
}3.2.2、挖坑法
int PartSort2(int* a, int left, int right)
{
int midi = GetMidIndex(a, left, right);
Swap(&a[left], &a[midi]);
int key = a[left];
int pit = left;
while (left < right)
{
while (left < right && a[right] >= key)
{
right--;
}
a[pit] = a[right];
pit = right;
while (left < right && a[left] <= key)
{
left++;
}
a[pit] = a[left];
pit = left;
}
a[left] = key;
return pit;
}
3.2.3、前后指针法
int PartSort3(int* a, int left, int right)
{
int midi = GetMidIndex(a, left, right);
Swap(&a[left], &a[midi]);
int keyi = left;
int pre = left, cur = left + 1;
while (cur <= right)
{
if (a[cur] < a[keyi] && a[++pre] != a[cur])
{
Swap(&a[cur], &a[pre]);
}
cur++;
}
Swap(&a[keyi], &a[pre]);
return pre;
}void QuickSort(int* a, int left, int right)
{
if (left >= right)
{
return;
}
if (right - left + 1 <=10)//当区间小于十时采用插入排序更快
{
InsertSort(a + left, right - left + 1);
}
else
{
int key = PartSort1(a, left, right);
//int key = PartSort2(a, left, right);
//int key = PartSort3(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1, right);
}
}3.2.4、非递归快速排序
void QuickSortNonR(int* a, int left, int right)
{
ST st;
StackInit(&st);
StackPush(&st, left);
StackPush(&st, right);
while (!StackEmpty(&st))
{
int end = StackTop(&st);
StackPop(&st);
int begin = StackTop(&st);
StackPop(&st);
int key = PartSort3(a, begin, end);
if (begin < key - 1)
{
StackPush(&st, begin);
StackPush(&st, key - 1);
}
if (key + 1 < end)
{
StackPush(&st, key + 1);
StackPush(&st, end);
}
}
StackDestory(&st);
}4、归并排序
基本思想：
是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
代码：
4.1、递归版
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 index = begin;
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++];
}
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
assert(tmp);
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}4.2、非递归版
非递归版归并排序，要注意对区间的控制
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
assert(tmp);
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
if (end1 >= n)//第一个区间的尾必须要小于数组最后一个元素的下标
{
end1 = n - 1;
}
if (begin2 >= n)//当第二个区间的头大于数组最后一个元素的下标则该区间不存在
{
begin2 = n;
end2 = n - 1;
}
if (begin2 < n && 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++];
}
}
memcpy(a, tmp, sizeof(int) * n);
gap *= 2;
}
}5、非比较排序
5.1、计数排序
基本思想：
1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中
代码：
void CountSort(int* a, int n)
{
int max = a[0], min = a[0];
for (int i = 1; i < n; i++)
{
if (max < a[i])
{
max = a[i];
}
if (min > a[i])
{
min = a[i];
}
}
int range = max - min + 1;
int* countA = (int*)malloc(sizeof(int) * range);
assert(countA);
memset(countA, 0, sizeof(int) * range);
for (int i = 0; i < n; i++)
{
countA[a[i] - min]++;
}
for (int i = 0, j = 0; i < range; i++)
{
while (countA[i]--)
{
a[j++] = i + min;
}
}
}
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
