直接插入排序时间复杂度O(N^2),空间复杂度O(1),最好情况是有序或接近有序,最差情况是逆序,有序时比希尔排序更好
希尔排序(缩小增量排序,其优化了直接插入排序)中,gap(一般为3)越大,前面大的数据可以越快到后面,后面小的数可以越快到前面。缺点是gap越大越不接近有序,若gap=1等于直接插入排序。希尔排序时间复杂度O(N^1.3~N^2)
选择排序时间复杂度O(N^2),最坏情况是有序时非常慢
交换函数
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
插入排序
// 直接插入排序
void InsertSort(int* a, int n)//把end+1向[0,end]中插入
{
assert(a);
for (int i = 0; i < n - 1; ++i)//注意范围控制,n-1是最后一个数下标
{
int end=i;//先把第一个数当成有序,然后不断插入数据
int tmp = a[end + 1];//tmp是需要插入的数据
while (end >= 0)
{
if (tmp < a[end])//挪动数据
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
a[end + 1] = tmp;
}
}
}
希尔排序
// 希尔排序
void ShellSort(int* a, int n)
{
int gap=n;
while (gap > 1)//gap>1相当于预排序,让数组接近有序
{
gap = gap / 3 + 1;//+1保证最后一次gap一定是1,这时相当于直接插入排序
//为什么边界是n - gap? 因为它后面没有足够的间距排序了,++i控制多组并排
for (int i = 0; i < n - gap; ++i)
{
int end = i;
int tmp = a[end + gap];//把tmp看作是插入的数据进行排序
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;//回退到前一个排序的数据
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
堆排序
// 堆排序
void AdjustDwon(int* a, int n, int root)//排升序建大堆,降序建小堆
{
int parent=root;
int child=parent*2+1;
while (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)
{
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]);//建堆选出最大的数在a[0],放到最后
AdjustDwon(a, end, 0);//再把次大的数放到倒数第二个位置,以此类推
--end;//每次调整的范围都减1
}
}
选择排序
// 选择排序
void SelectSort(int* a, int n)//在[begin,end]中找出最大和最小的数的下标,一次选两个数
{
assert(a);
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini, maxi;
mini = 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位置重叠,则maxi位置需要修正!
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);//把大的数放在后面
//缩小范围
begin++;
end--;
}
}
计数排序
//时间复杂度O(N+range),空间复杂度O(range),只适用整形,若是浮点数或字符串排序用比较排序
void CountSort(int* a, int n)
{
assert(a);
int max = a[0];
int min = a[0];
for (int i = 1; i < n; i++)
{
if (a[i] > max)
max = a[i];
if(a[i]<min)
min = a[i];
}
int range = max - min + 1;//范围是最大值-最小值+1
int* countArr = (int*)malloc(sizeof(int) * range);//统计数据的数组
memset(countArr, 0, sizeof(int) * range);//将数组初始化为0
for (int i = 0; i < n; i++)//统计次数
{
countArr[a[i] - min]++;
}
int index = 0;
for (int j = 0; j < range; j++)//排序用相对位置,节省空间
{
while (countArr[j]--)
{
a[index++] = j + min;
}
}
free(countArr);
}
代码测试
void PrintArray(int* a, int n)//打印数据
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void TestInsertSort()
{
int a[] = { 1,0 ,5,2,1,4,6,3,2,5,4,8,9};
PrintArray(a, sizeof(a) / sizeof(int));
InsertSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestShellSort()
{
int a[] = { 10,9,0,7,6,4,4,7,2,1,7 };
PrintArray(a, sizeof(a) / sizeof(int));
ShellSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestSelectSort()
{
int a[] = { 10,9,7,7,4,5,9,3,2,1,7 };
PrintArray(a, sizeof(a) / sizeof(int));
SelectSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestHeapSort()
{
int a[] = { 10,9,8,7,4,5,4,3,7,1,7 };
PrintArray(a, sizeof(a) / sizeof(int));
HeapSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
void TestCountSort()
{
int a[] = { 10,9,8,7,6,5,4,5,8,9,10,4,6,8,7};
PrintArray(a, sizeof(a) / sizeof(int));
CountSort(a, sizeof(a) / sizeof(int));
PrintArray(a, sizeof(a) / sizeof(int));
}
int main()
{
//TestInsertSort(); //直接插入
//TestShellSort(); //希尔排序
//TestSelectSort(); //选择排序
//TestHeapSort(); //堆排序
//TestCountSort(); //计数排序
return 0;
}