简单的排序
以a[5]为例
a[5] = {9,6,15,4,2};
1.简单选择法排序
遍历数组把数组的最小值(或是最大值)找到，然后放在数组0号位置上。然后划掉0号位置，遍历剩下的数字找到最值，然后放到数组1号位置上，以此类推
从i个记录中挑选最小记录需要比较i-1次
第i（i=0~n-2）趟从n-i记录中挑选最小记录需要比较n-i-1次
对n个记录进行简单选择排序，比较次数为:n*(n-1)/2
移动次数，正序为最小值0，反序为最大值3(n-1)
简单选择排序最好，最坏和平均时间复杂度均为O(n^2)
简单选择排序的时间复杂度和初始序列的顺序无关
代码片段如下
// c
for(i=0;i<5;i++){
min = a[i];
k_min = i;
for(j=i+1;j<5;j++){
if(min>a[j]){
min = a[j];
k_min = j;
}
}
if(k_min != i){
a[k_min] = a[i];
a[i] = min;
}
}
# python
for i in range(len(a)):
min = a[i]
k_min = i
for j in range(i+1,len(a)):
if min > a[j]:
min = a[j]
k_min = j
if k_min != i:
a[k_min] = a[i]
a[i] = min
2.冒泡法排序
这个算法的名字由来是因为越大的元素（或者最小）会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
选定一个方向进行扫描，逐个比较数组中相邻的两个数组元素的值，将较小的数（从小到大排序）排在较大的数前面
图解如下
最好的情况——关键字在记录序列中正序：
只需要进行1趟冒泡
比较次数 = n-1
移动次数 = 0;
最坏的情况——关键字在记录序列中反序：
需要进行n-1趟冒泡
比较次数 = n(n-1)/2
移动次数 = 3n*(n-1)/2
所以冒泡排序最好的时间复杂度为O(n),最坏时间复杂度为O(n^2);
改进后的冒泡排序代码片段如下
for (int i = 1; i < size; i++) //外层循环1~size-1
{
bool exchange = false;
for (int j = size - 1; j >= i; j--)
{
//内层循环i~size-1
if (a[j] < a[j - 1])
{
exchange = true; //如果一趟冒泡后没有交换任何关键字则说明该序列已经排好
swaq(a[j], a[j - 1]); //交换两个数
}
}
if (exchange == false)
{
break;
}
}
# python
def swap(a,b):
return b,a
for i in range(1,len(a)):
exchange = False
for j in range(len(a)-1,i-1,-1):
if a[j] < a[j-1]:
exchange = True
a[j], a[j-1] = swap(a[j], a[j-1])
if exchange == False:
break
3.交换排序
和冒泡排序的区别在于
冒泡排序是边比较边移动，逐个比较相邻的元素；而交换排序是选定一个位置不变，逐个比较相对大小并与固定位置交换
图解如下
代码片段如下：
for(i=0;i<size;i++){
for(j=i+1;j<size;j++){
if(a[j]>a[j-1]){
swap(a[j],a[j-1]);
}
}
}
def swap(a,b):
return b,a
for i in range(len(a)):
for j in range(i+1,len(a)):
if a[j] > a[j-1]:
swap(a[j],a[j-1])
4.直接插入排序法
基本思路：把初始序列分成有序区和无序区，把无序区的元素按照有序区的顺序一一插入有序区，直到有序区包含了所有数据。注意有序区不一定是已经排好序的。
初始时，有序区只有一个元素（只有一个元素可认为有序），把无序区里面n-1个元素插入有序区。
for(i=1;i<size;i++){
if(a[i]<a[i-1]){ //只有当反序的时候才进入排序流程
tmp = a[i];
j = i-1;
do{ //找a[i]的插入位置
a[j+1] = a[j]; //将关键字大于a[i]的记录向后移
j--;
}while((j>=0) && (a[j]>tmp));
a[j+1] = tmp; //在j+1出插入
}
}
在最好的情况下——关键字在记录序列中正序
比较次数 = n-1；元素移动次数 = 0；
最好的情况下时间复杂度为O(n)
最坏的情况下——关键字在记录序列中反序
比较次数 = n(n-1)/2；元素移动次数 = (n-1)(n+4)/2；
最坏的情况时间复杂度为O(n^2)
平均时间复杂度为O(n^2)
排序和查找<stdlib.h>
qsort
void
qsort( void *base, size_t n_elements, size_t el_size, int ( *compare )( void const *, void const * ) ) ;
最后一个参数是一个函数指针
bsearch
void
bsearch( void const *key, void const *base, size_t n_elements, size_t el_size, int ( *compare )( void const *, void const * ) );
bsearch的原理是二分查找，数组需要预先排序
#include <stdio.h>
#include <stdlib.h>
int
compare( void const *a, void const *b )
{
return ( *( int* )a ) > ( *( int* )b ) ? 1 : 0;
}
int
main( int argc, char *argv[] )
{
int i;
int key = 110;
int *ans;
int a[] = { 0, 110, 222, 55 };
qsort( a, sizeof(a) / sizeof( int ), sizeof( int ), compare );
for( i = 0; i < sizeof( a ) / sizeof( int ); i++ ){
printf("%d ", a[i]);
}
ans = ( int* )bsearch( &key, a, sizeof( a ) / sizeof( int ), sizeof( int ), compare );
if( ans != NULL ){
printf("\n%d", *ans);
}else{
printf("\nNot Found");
}
return 0;
}
