冒泡排序
- 从第一个数据开始到第n-1个数据,依次和后面一个数据两两比较,数值小的在前。最终,最后一个数据(第n个数据)为最大值。
- 从第一个数据开始到第n-2个数据,依次和后面一个数据两两比较,数值小的在前。最终,倒数第二个数据(第n-1个数据)为第二个最大值。
- 从第一个数据开始到第n-3个数据,依次和后面一个数据两两比较,数值小的在前。最终,倒数第三个数据(第n-2个数据)为第三个最大值。
- 最多重复操作n-1次。
时间复杂度:最好情况 O(n),最坏情况 O(),平均情况 O()
- 若已是排好的,从开头到最后,两两比对,需要n-1次比对,无需交换,一轮结束,则时间约n,即 O(n)。
- 若是乱序,则需最多n-1次重复操作,虽然每次重复操作的比对次数减1,但总时间约,即O()。
空间复杂度:O(1)
- 在原位置排序,只重复使用了用于交换的临时空间,不随数据量的变动而变动,空间使用为常量(1)。
C语言实现:(bubblesort**.**c)
cpp
#include <stdio.h>
/* function prototype */
void bubble(int *, int); // bubble sort
void traverse(int *, int); // show element one by one
/* main function */
int main(void)
{
int arr[] = {4,2,6,9,5,1,3};
int n = sizeof(arr) / sizeof(int);
traverse(arr, n);
bubble(arr, n);
printf("[ after bubble sort ] ");
traverse(arr, n);
return 0;
}
/* subfunction */
void bubble(int *array, int length) // bubble sort
{
for(int i = length - 1; i > 0; i--)
{
int ischange = 0;
for(int j = 0; j < i; j++)
{
if(array[j] > array[j+1])
{
int tmp = array[j];
array[j] = array[j+1];
array[j+1] = tmp;
ischange = 1;
}
}
if(ischange == 0) return ;
}
}
void traverse(int *array, int length) // show element one by one
{
printf("elements(%d): ", length);
for(int k = 0; k < length; k++)
{
printf("%d ", array[k]);
}
printf("\n");
}
编译链接: gcc -o bubblesort bubblesort**.**c
执行可执行文件: ./bubblesort
选择排序
- 从第一个数据开始到最后,挑选最小值,放入第一个位置。
- 从第二个数据开始到最后,挑选最小值,放入第二个位置。
- 从第三个数据开始到最后,挑选最小值,放入第三个位置。
- 共重复操作n-1次。
时间复杂度:最好情况 O(),最坏情况 O(),平均情况 O()
- 从开头到最后,挑选最小值,需要n-1次比对。重复n-1次操作,虽然每次重复操作的比对次数减1,但总时间约,即O()。
空间复杂度:O(1)
- 在原位置排序,只重复使用了用于交换的临时空间,不随数据量的变动而变动,空间使用为常量(1)。
C语言实现:(selectsort**.**c)
cpp
#include <stdio.h>
/* function prototype */
void select(int *, int); // select sort
void traverse(int *, int); // show element one by one
/* main function */
int main(void)
{
int arr[] = {4,2,6,9,5,1,3};
int n = sizeof(arr) / sizeof(int);
traverse(arr, n);
select(arr, n);
printf("[ after select sort ] ");
traverse(arr, n);
return 0;
}
/* subfunction */
int findmin(int *array, int m, int n) // find the minimum data, return index
{
int minindex = m, mindata = array[m];
int j;
for(j = m + 1; j < n; j++)
{
if(mindata > array[j])
{
minindex = j;
mindata = array[j];
}
}
return minindex;
}
void select(int *array, int length) // select sort
{
for(int i = 0; i < length - 1; i++)
{
int min = findmin(array, i, length);
if(i != min)
{
int tmp = array[i];
array[i] = array[min];
array[min] = tmp;
}
}
}
void traverse(int *array, int length) // show element one by one
{
printf("elements(%d): ", length);
for(int k = 0; k < length; k++)
{
printf("%d ", array[k]);
}
printf("\n");
}
编译链接: gcc -o selectsort selectsort**.**c
执行可执行文件: ./selectsort
插入排序
- 第二个数据和第一个数据,两两比较,数值小的在前。
- 从第三个数据开始到第一个数据,依次和前面一个数据两两比较,数值小的在前。
- 从第四个数据开始到第一个数据,依次和前面一个数据两两比较,数值小的在前。
- 最多重复操作n-1次。
时间复杂度:最好情况 O(n),最坏情况 O(),平均情况 O()
- 若已是排好的,无需交换,从第二个数据到最后,依次只需和前面一个数据两两比对,需要n-1次比对,则时间约n,即 O(n)。
- 若是乱序,则除了和前面数据两两比对(需n-1次比对),还需重复往前比对,最多比对n-1次,总时间约,即O()。
空间复杂度:O(1)
- 在原位置排序,只重复使用了用于交换的临时空间,不随数据量的变动而变动,空间使用为常量(1)。
C语言实现:(insertsort**.**c)
cpp
#include <stdio.h>
/* function prototype */
void insertsort(int *, int); // insert sort
void traverse(int *, int); // show element one by one
/* main function */
int main(void)
{
int arr[] = {4,2,6,9,5,1,3};
int n = sizeof(arr) / sizeof(int);
traverse(arr, n);
insertsort(arr, n);
printf("[ after insert sort ] ");
traverse(arr, n);
return 0;
}
/* subfunction */
void insertsort(int *array, int length) // insert sort
{
int ischange = 0;
for(int i = 1; i < length; i++)
{
for(int j = i; j >= 0; j--)
{
if(array[j-1] > array[j])
{
int tmp = array[j];
array[j] = array[j-1];
array[j-1] = tmp;
ischange = 1;
}
if(ischange == 0) return ;
}
}
}
void traverse(int *array, int length) // show element one by one
{
printf("element(%d): ", length);
for(int k = 0; k < length; k++)
{
printf("%d ", array[k]);
}
printf("\n");
}
编译链接: gcc -o insertsort insertsort**.**c
执行可执行文件: ./insertsort