1.冒泡排序
动图展示
思路：两个相邻的元素进行比较 升序情况下 前一个大于后一个 就进行交换 一趟之后 大的数被交换到最后。
代码实现：
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
// 冒泡排序
void BubbleSort(int* a, int n)
{
int i = 0;
int j = 0;
for (i = 0; i < n - 1; i++)
{
//假设有序
int flag = 1;
for (j = 0; j < n - 1 - i; j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], &a[j + 1]);
flag = 0;
}
}
//已经有序
if (flag == 1)
{
break;
}
}
}总结：时间复杂度O(N^2) 空间复杂度O(1) 在比较的数据较多时候 效率比较低 不适合实践使用 更适用于教学。
2.插入排序
动图展示：
思路：认为[0,end]有序 end+1位置的值存到tmp中 比tmp大的数往后挪 最后将tmp插入到[0,end]中，保持有序 。
代码实现：
// 插入排序
void InsertSort(int* a, int n)
{
// [0, n-1]
for (int i = 0; i < n - 1; i++)
{
// [0, n-2]是最后一组
// [0,end]有序 end+1位置的值插入[0,end]，保持有序
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;
}
}3.希尔排序
希尔排序=预排序（使数据接近有序）+插入排序 。
代码实现：
void ShellSort(int* a, int n)
{
//多组并着走
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
//+1保证最后一个gap一定是1
//gap > 1 时是预排序
//gap == 1 时是插入排序
//超过n-gap越界
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;
}
}
}总结：时间复杂度O(n^1.3) 空间复杂度O(1) 。
4.选择排序
思路：选出最小的数放到左边 最大的放到右边。
需特殊处理begin==maxi的情况
代码实现
void SelectSort(int* a, int n)
{
int begin = 0,end = n - 1;
while (begin < end)
{
int mini = begin, maxi = begin;
for (int i = begin + 1; i <= end; ++i)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
if (begin == maxi)
maxi = mini;
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
}5.堆排序
代码实现
void AdjustDown(int* a, int n, int parent)
{
// 先假设左孩子小
int child = parent * 2 + 1;
while (child < n) // child >= n说明孩子不存在，调整到叶子了
{
// 找出小的那个孩子
if (child + 1 < n && a[child + 1] > a[child])
{
++child;
}
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
// 向下调整建堆 O(N)
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
// O(N*logN)
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}6.快速排序
（1）hoare版本
动图展示:
代码实现
void QuickSortPart1(int* a, int left, int right)
{
if(left>=right)
return;
int keyi = left;
int begin = left, end = right;
while (begin < end)
{
//右边找小
while (begin < end && a[end] >= a[keyi])
{
--end;
}
//左边找大
while (begin < end && a[begin] <= a[keyi])
{
++begin;
}
Swap(&a[begin], &a[end]);
}
Swap(&a[keyi], &a[begin]);
keyi = begin;
//[left ,keyi-1] keyi [keyi+1,right]
//递归
QuickSortPart1(a, left, keyi - 1);
QuickSortPart1(a, keyi + 1, right);
}（2）挖坑法
动图展示：
代码实现
void QuickSortPart2(int* a, int left, int right)
{
if (left >= right)
return;
int key = a[left];
int hole = left;
int begin = left;
int end = right;
while (begin < end)
{
while (begin < end && a[end] >= key)
{
--end;
}
a[hole] = a[end];
hole = end;
while (begin < end && a[begin] <= key)
{
++begin;
}
a[hole] = a[begin];
hole = begin;
}
//填坑
a[hole] = key;
QuickSortPart2(a, left, hole - 1);
QuickSortPart2(a, hole+1, right);
}(3)前后指针法
动图展示：
代码实现
void QuickSortPart3(int* a, int left, int right)
{
if (left >= right)
return;
int keyi = left;
int prev = left;
int cur = prev+1;
while (cur <= right)
{
if (a[cur] < a[keyi] && ++prev != cur)
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[prev], &a[keyi]);
keyi = prev;
QuickSortPart3(a, left, keyi- 1);
QuickSortPart3(a,keyi+1, right);
}7.归并排序
void _MergeSort(int* a, int* tmp, int begin, int end)
{
if (begin >= end)
return;
int mid = (begin + end) / 2;
_MergeSort(a, tmp, begin, mid);
_MergeSort(a, tmp, mid + 1, end);
//[begin,mid] [mid+1,end]
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
//左右都有序 小的拿到tmp中尾插
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] < a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
//如果比较之后 左右区间还有数 直接拿下来尾插到tmp中
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
//将tmp中数据移动到a中
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)
{
perror("malloc fail!");
return;
}
//子函数 完成函数功能的一部分
_MergeSort(a, tmp, 0, n - 1);
free(tmp);
tmp = NULL;
}
总结：时间复杂度O(N*log N) 空间复杂度O(N)。
8.非递归归并排序
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
// gap每组归并数据的数据个数
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
// [begin1, end1][begin2, end2]
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
//printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);
// 第二组都越界不存在，这一组就不需要归并
if (begin2 >= n)
break;
// 第二的组begin2没越界，end2越界了，需要修正一下，继续归并
if (end2 >= n)
end2 = n - 1;
int j = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
//printf("\n");
gap *= 2;
}
free(tmp);
tmp = NULL;
}9.计数排序
void CountSort(int* a, int n)
{
//找出最小和最大的数
int min = a[0], max = a[0];
for (int i = 1; i < n; i++)
{
if (a[i] < min)
min = a[i];
if (a[i] > max)
max = a[i];
}
int range = max - min + 1;
int* count = (int*)calloc(range, sizeof(int));
if (count == NULL)
{
perror("calloc fail");
return;
}
//计数
for (int i=0;i<n;i++)
{
count[a[i] - min]++;
}
//排序
int j = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
free(count);
}总结：时间复杂度:O(N+range) 只适合整数/适合范围集中的情况 空间范围度：O(range)。
扫一扫
23万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
