目录
1，插入排序
A，思路
不断抽新卡，往有序数组里面放，[0,end]有序，把end+1插入，保持有序
B，实现
void InsertSort(int* a, int n)
{
assert(a);
// [0,end]有序，把end+1插入，保持有序
for (int i = 0; i < n - 1; i++)
{
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，希尔排序
A，思路
间隔gap抽卡分组，单独插入排序，先预排序（接近有序）gap > 1，再直接插入排序（有序）gap = 1
B，实现
void ShellSort(int* a, int n)
{
assert(a);
int gap = n;
while (gap > 1)
{
//gap>1 预排序 //gap=1 直接排序
gap = gap / 3 + 1;
//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;
}
}
}3，选择排序
A，思路
选出最大和最小的，放数组的头尾两边
B，实现
void SelectSort(int* a, int n)
{
assert(a);
//头尾放数据的位置
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[mini])
mini = i;
if (a[i] > a[maxi])
maxi = i;
}
//交换位置放两边，放数据位置向中间挪动
Swap(&a[begin],&a[mini]);
//避免重复换位，如果begin为maixi值，修正maxi成mini
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end],&a[maxi]);
++begin;
--end;
}
}4，堆排序
A，思路
先把无序数组变成无序小根堆，再把无序小根堆变成有序大根堆
B，实现
void AdjustDwon(int* a, int size, int parent)
{
assert(a);
//从树根开始，选出左右孩子小的一个，小的孩子向上调整位置
//如果小的孩子比父亲小，就交换位置,否则无需调整，直到变成树叶
int child = parent * 2 + 1;
while (child < size)//当child = szie，变成树叶，结束循环
{
if (child + 1 < size && a[child + 1] > a[child])//大根堆
//if (child + 1 < size && a[child + 1] < a[child])//小根堆
{
++child;//选右边的孩子
}
if (a[child] > a[parent])//大根堆
//if (a[child] < a[parent])//小根堆
{
Swap(&a[child], &a[parent]);
//更新下标，继续循环
parent = child;
child = parent * 2 + 1;
}
else
{
break;//无需调整
}
}
}
void HeapSort(int* a, int size)
{
assert(a);
// 把无序数组变成无序小根堆
//从倒数第一个非叶子节点（最后一个节点的父亲）开始向下调整，走到树根结束
for (int i = (size - 1 - 1) / 2; i >= 0; i--)
{
AdjustDwon(a, size, i);
}
//把无序小根堆变成有序大根堆，所有元素依次从大到小排序
//选出最小的数替换最后面的数，然后size-1隔离掉
//继续调整少了一个元素的堆，继续选出次小的数，继续隔离，最后变成有序大根堆
// O(N*logN)
int end = size - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDwon(a, end, 0);
end--;
}
}5，冒泡排序
A，思路
左边大于右边则交换，冒泡一趟下来最大的在最右边
B，实现
void BubbleSort(int* a, int n)
{
assert(a);
for (int j = 0; j < n; ++j)
{
int exchange = 0;
for (int i = 1; i < n - j; ++i)
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
{
break;//如果没有交换，则原数组有序,直接跳出
}
}
}6，快速排序
A，思路
先选key，key左右的元素交换，左边区间比key小，右边区间比key大
B，实现
//三数取中
int QetMidIndex(int* a, int begin, int end)
{
int mid = (begin + end) / 2;
if (a[begin] < a[mid])
{
if (a[mid] < a[end]) return mid;
else if (a[end] < a[begin]) return begin;
else return end;
}
else //当a[begin] >= a[mid]
{
if (a[mid] > a[end]) return mid;
else if (a[end] > a[begin]) return begin;
else return end;
}
}
// 快速排序前后指针法
int PartSort3(int* a, int begin, int end)
{
int keyi = begin;
int prev = begin;
int cur = begin + 1;
//三数取中选key
int midi = QetMidIndex(a, begin, end);
Swap(&a[midi],&a[keyi]);
while (cur <= end)
{
//先找小的值往左换，找到就后置++，++prev之后再看与cur是否相等
//如果相等，就无需自己换位自己
if (a[cur] < a[keyi] && ++prev != cur)
{
Swap(&a[prev],&a[cur]);
}
cur++;
}
Swap(&a[prev],&a[keyi]);
return prev;
}
void QuickSort(int* a, int begin, int end)
{
//区间不存在，或者只有一个值，则不需要再处理
if (begin >= end)
{
return;
}
if (end - begin > 10)
{
//[begin, keyi - 1] key [keyi + 1, end]
int keyi = PartSort3(a, begin, end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
else
{
InsertSort(a + begin, end - begin + 1);
}
}7，归并排序
A，思路
左右两个有序区间，归并成一个大有序区间
B，实现
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);
//[begin,mid][mid+1,end]
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
//左右区间归并成一个区间
int i = begin1;
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 + 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 fail\n");
exit(-1);
}
//归并排序递归
_MergeSort(a, 0, n - 1, tmp);
//释放临时数组
free(tmp);
}8，计数排序
A，思路
统计每个数出现几次，再依次回写到原数组
B，实现
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[i];
if (a[i] > max)
max = a[i];
}
//创建数组
int range = max - min + 1;
int* tmp = (int*)malloc(sizeof(int) * range);
if (tmp == NULL)
{
printf("malloc fail\n");
exit(-1);
}
memset(tmp, 0, sizeof(int) * range);
//统计次数
for (int i = 0; i < n; ++i)
{
tmp[a[i] - min]++;//负数也能记录
}
//回写排序
int j = 0;
for (int i = 0; i < range; ++i)
{
//出现几次，回写几个i+min
while (tmp[i]--)
{
a[j++] = i + min;
}
}
free(tmp);
}给我点个赞吧，666（OVO）666 ！！！
扫一扫
7662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
