基础排序算法

1.选择排序：

cs 复制代码

#include<stdio.h>
voidswap(int*a,int*b) {
intt = *a;
*a= *b;
*b= t;
}void hhh(int* nums,int n) {
for (int i = 1; i < n; i++) {//控制趟次,当有n个元素时，最多只需要排n-1趟
intmaxIndex = 0;
for (int j = 0; j<= n - i; j++) {
if(nums[maxIndex] < nums[j]) {
maxIndex= j;
}
}
if(maxIndex != n - i) {
swap(&nums[maxIndex],&nums[n - i]);
}
}
}
int main() {
intnums[] = { 1,5,2,4,6,7 };
intn = sizeof(nums) / sizeof(int);
hhh(nums,n);
for(int i = 0; i < n; i++) {
printf("%d",nums[i]);
}
return0;
}

时间复杂度：

最好情况：O(n^2)

2.最坏情况：O(n^2)

空间复杂度：

选择排序的空间复杂度：O(1)。

稳定性：

不稳定

2.冒泡排序

cs 复制代码

#include<stdio.h>
#include<stdlib.h>
void swap(int* a,int* b) {
intt = *a;
*a= *b;
*b= t;
}
void bubblesort(int*nums, int n) {
//n个元素最多只需要进行n-1趟排序
//待排序序列下标范围 0~n-i
for (int i = 1; i < n; i++) {//控制趟数
intflag = 0;
for (int j = 0; j < n - i; j++) {//待排序序列下标范围
if(nums[j] > nums[j + 1]) {
flag= 1;
swap(&nums[j], &nums[j + 1]);//交换两个变量的值
//址传递
}
}
if (flag == 0) {//序列已经排整好了 不需要再排下去了
return0;
}
}
}
int main() {
int n;//表示数组当中元素个数
scanf("%d",&n);
int*nums = (int*)malloc(sizeof(int) * n);
if(nums == NULL) return 0;
for(int i = 0; i < n; i++) {
scanf("%d",&nums[i]);
}
bubblesort(nums, n);//冒泡排序   从小到大
for(int i = 0; i < n; i++) {
printf("%d", nums[i]);
}
free(nums);
return0;
}

时间复杂度：

1.最好情况:O(n)

2.最坏情况：O(n^2)。

空间复杂度：

冒泡排序的空间复杂度：O(1)。

稳定性：

稳定

3.插入排序：

cs 复制代码

#include<stdio.h>
void hhh(int* nums,int n) {
for (int i = 1; i < n; i++) {//无序区的第一个数的下标
int j = i - 1;//有序区的最后一个数的下标
int t = nums[i];//用t来记录无序区首个数字的下标
for(; j >= 0; j--) {
if(t < nums[j]) {
nums[j+ 1] = nums[j];
}
else{
break;//当无序区的第一个数大于有序区的最后一个数时，退出循坏无需继续比较
}
}
nums[j+ 1] = t;
}
}
int main() {
intnums[] = { 1,5,2,4,6,7 };
intn = sizeof(nums) / sizeof(int);
hhh(nums,n);
for(int i = 0; i < n; i++) {
printf("%d",nums[i]);
}
return0;
}

时间复杂度：

最好情况：O(n)

最坏情况：O(n^2)

空间复杂度：

插入排序的空间复杂度：O(1)。

稳定性：

稳定

4.计数排序

cs 复制代码

#include<stdio.h>
#include<stdlib.h>
int Max(int* nums,int n) {
intmax = nums[0];
for(int i = 1; i < n; i++) {
if(nums[i] > max) {
max= nums[i];
}
}
returnmax;
}
void hhh(int* nums,int n) {
intmax = Max(nums, n);
int* bucket = (int*)calloc((max + 1), sizeof(int));//calloc能自动初始化为0；
for(int i = 0; i < n; i++) {
bucket[nums[i]]++;
}
int Index = 0;//用于记录，拿回来的数据放到nums的什么位置
for(int i = 0; i <= max; i++) {
while(bucket[i]--) {
nums[Index++]= i;
}
}
}
int main() {
intnums[] = { 1,5,2,4,6,7 };
intn = sizeof(nums) / sizeof(int);
hhh(nums,n);
for(int i = 0; i < n; i++) {
printf("%d", nums[i]);
}
return0;
}

时间复杂度：

最好情况时间复杂度：O(n + k)

最坏情况时间复杂度：O(n + k)

这里的n是待排序元素的个数，k是待排序序列中元素值的范围（最大值与最小值的差加1）。

空间复杂度：

计数排序的空间复杂度：O(n + k)。

稳定性：

稳定