排序
排序的概念及应用
排序相关概念
排序
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序
数据元素全部放在内存中的排序。
外部排序
数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
排序的运用
图源淘宝
常见排序算法
常见排序算法的实现
插入排序
直接插入排序
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
// 插入排序
void InsertSort(int* a, int n)
{
for(int i = 0;i<n-1;i++)
{
int end = i;
int tmp = a[end+1];
while (end >= 0 && a[end] > tmp)
{
a[end + 1] = a[end];
end--;
}
a[end + 1] = tmp;
}
}
希尔排序
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = 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 end = i;
int tmp = a[end + gap];
while (end >= 0 && a[end] > tmp)
{
a[end + gap] = a[end];
end-=gap;
}
a[end + gap] = tmp;
}
}
}
选择排序
选择排序
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
// 选择排序
void SelectSort(int* a, int n)
{
int end = n - 1;
int begin = 0;
while (end > begin)
{
int mini = begin;
int maxi = end;
for (int i = begin; i <= end; ++i)
{
if (a[mini] > a[i])
{
Swap(&a[mini], &a[i]);
}
if (a[maxi] < a[i])
{
Swap(&a[maxi], &a[i]);
}
}
begin++;
end--;
}
}
堆排序
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//堆排序
void AdjustDwon(int* a, int n, int parent)
{
int child = parent * 2 +1;
while (child < n)
{
if (child + 1 < n&& a[child] < a[child + 1])
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)
{
for (int i = (n - 1) / 2; i >= 0; i--)
AdjustDwon(a, n, i);
int end = n;
while(end)
{
end--;
Swap(&a[end], &a[0]);
AdjustDwon(a, end, 0);
}
}
交换排序
冒泡排序
void swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
// 冒泡排序
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 1; j < n - i; j++)
{
if (a[j] < a[j - 1])
swap(&a[j], &a[j - 1]);
}
}
}
快速排序
void swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//三数取中
int Getmidi(int* a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] > a[right])
{
if (a[right] > a[mid])
return right;
else if (a[left] > a[mid])
return mid;
else
return left;
}
else //(a[left] < a[right])
{
if (a[right] < a[mid])
return right;
else if (a[left] < a[mid])
return mid;
else
return left;
}
}
// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
//int midi = Getmidi(a, left, right);
//swap(&a[left], &a[midi]);
int keyi = left;
while (left < right)
{
//先右后左
//找小
while (a[right] >= a[keyi] && left < right)
right--;
//找大
while (a[left] <= a[keyi] && left < right)
left++;
swap(&a[left], &a[right]);
}
swap(&a[left], &a[keyi]);
return left;
}
// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
int midi = Getmidi(a, left, right);
swap(&a[left], &a[midi]);
int key = a[left];
int hole = left;
while (left < right)
{
//右边找小，找到把右边填到坑里面，右边形成新坑
while (a[right] >= key && left < right)
right--;
a[hole] = a[right];
hole = right;
//找大，找到把左边填到坑里面，左边形成新坑
while (a[left] <= key && left < right)
left++;
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
/*int midi = Getmidi(a, left, right);
swap(&a[left], &a[midi]);*/
int keyi = left;
int prev = left;
int cur = left + 1;
while (cur <= right)
{
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 left, int right)
{
if (left >= right)
return;
int keyi = PartSort3(a, left, right);
QuickSort(a, left, keyi-1);
QuickSort(a, keyi + 1, right);
小区间优化，小区间不再递归分割排序，降低递归次数
//if ((end - begin + 1) > 10)
//{
// int keyi = PartSort3(a, begin, end);
// // [begin, keyi-1] keyi [keyi+1, end]
// QuickSort1(a, begin, keyi - 1);
// QuickSort1(a, keyi + 1, end);
//}
//else
//{
// InsertSort(a + begin, end - begin + 1);
//}
}
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
Stack ST;
Stack *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 keyi = PartSort3(a, begin, end);
// [begin,keyi-1] keyi [keyi+1, end]
if (keyi + 1 < end)
{
StackPush(st, keyi + 1);
StackPush(st, end);
}
if (begin < keyi - 1)
{
StackPush(st, begin);
StackPush(st, keyi - 1);
}
}
StackDestroy(st);
}
归并排序
void _MergeSort(int* a, int* tmp, int begin, int end)
{
if (end <= begin)
return 0;
int mid = (begin + end) / 2;
int begin1 = begin,begin2 = mid+1;
int end1 = mid, end2 = end;
_MergeSort(a, tmp, begin1, end1);
_MergeSort(a, tmp, begin2, end2);
int i = begin;//使得归并后的位置和归并前一致
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, sizeof(int) * (end - begin + 1));
}
// 归并排序递归实现
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
_MergeSort(a, tmp, 0, n - 1);
free(tmp);
}
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i, begin2 = i+gap;
int end1 = i+gap-1, end2 = i+2*gap-1;
//第二组不存在，不用归并了
if (begin2 >= n)
break;
//越界了，修正一下
if (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 + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;
}
free(tmp);
}
非比较排序——计数排序
// 计数排序
void CountSort(int* a, int n)
{
int max = a[0], min = 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;//要加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 < 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);
}
排序算法复杂度及稳定性分析
1405
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
