排序算法
一、 首先说明一个几个概念
1） 如果待排序列中有两个相同的关键字 Ki = Kj，其顺序是Ki在Kj之前。如果经过排序之后，Ki 和 Kj的顺序颠倒了，则说明这个排序方法是不稳定的。否则则是稳定排序。
2）在内存中就可以完成的排序过程，称为内部排序。如果待排数据量很大，内存不够容纳全部数据，在排序过程中必须对外存进行访问，则叫做外部排序。
二、排序算法1、直接插入排序
时间复杂度为O(N^2)，空间复杂度为O(1)，关于插入排序的概念可以谷歌、百度，下面直接上代码
#include<stdio.h>
#define N 6
void inc_sort(int* keys,int size);
int main()
{
int i;
int array[6] = {49,38,65,97,76,13};
inc_sort(array,N);
for(i = 0;i < N;i++)
{
printf("%d ",array[i]);
}
printf("\n");
return 0;
}
void inc_sort(int* keys,int size)
{
int tmp;
int i,j;
for(i = 1;i < size;i++)
{
tmp = keys[i];
for(j = i -1;j >= 0;j--)
{
if(tmp < keys[j])
{
keys[j+1] = keys[j];
}
else break;
}
keys[j+1] = tmp;
}
}2、希尔排序
希尔排序是对直接插入排序的改良，其时间复杂度是O(NlogN)，空间复杂度为O(1)希尔排序是不稳定的。希尔自己推荐步长为N/2，但是在经过很多人的测试后，发现如果采用步长为1、3、5、7……这样的步长，要优于其他的步长，这样的步长有个特点是相邻步长之间（除1外）没有公因子。
#include<stdio.h>
#define N 6
void shell_sort(int* keys,int size);
int main()
{
int i;
int array[6] = {49,38,65,97,76,13};
shell_sort(array,N);
for(i = 0;i < N;i++)
{
printf("%d ",array[i]);
}
printf("\n");
return 0;
}
void shell_sort(int* keys,int size)
{
int tmp,step;
int i,j;
step = size/3 + 1;
do
{
for(i = step; i < size; i++)
{
tmp = keys[i];
for(j = i - step ;j >= 0;j -= step )
{
if(tmp < keys[j])
{
keys[j+step] = keys[j];
}
else break;
}
keys[j+step] = tmp;
}
step = step / 3 + 1;
}while(step > 1);
}
3、冒泡排序
冒泡排序是比较直观易懂的排序算法，所以历来是教科书的必选，冒泡排序的时间复杂度为O(N^2),空间复杂度为O(N)，冒泡是稳定算法。
下面的冒泡写法可能与传统的冒泡稍有改进，不同的地方在于交换数据上，自己体会吧。
#include<stdio.h>
#define N 6
void bubble_sort(int* keys,int size);
int main()
{
int i;
int array[6] = {49,38,65,97,76,13};
bubble_sort(array,N);
for(i = 0;i < N;i++)
{
printf("%d ",array[i]);
}
printf("\n");
return 0;
}
void bubble_sort(int* keys,int size)
{
int tmp,addr;
int i,j;
for(i = 0;i < size;i++)
{
tmp = keys[i];
addr = i;
for(j = i + 1 ;j < size;j++)
{
if(tmp > keys[j])
{
tmp = keys[j];
addr = j;
}
}
keys[addr] = keys[i];
keys[i] = tmp;
}
}4、快速排序
快速排序是分治思想的一种实现，其时间复杂度为O(NlogN)，快速排序是不稳定的。
具体的做法是：对待排序列keys[n]确定两个指针(low=0，high=n-1)。然后取第一个关键字keys[0]作为pivotkey(枢轴)。首先从high所指的位置起向前搜索找到第一个关键字小于pivotkey的记录，并将这个记录的关键字与pivotkey交换。然后从low所指的位置向后搜索，找到第一个关键字大于pivotkey的记录，并交换。轮流重复这两个步骤直到low=high位置。这样一个过程我们叫做一次快排(又叫一次划分)。
#include<stdio.h>
#define N 6
void quick_sort(int* keys,int size);
void quick_sort_impl(int* keys,int left,int right);
int main()
{
int i;
int array[6] = {49,38,65,97,76,13};
quick_sort(array,N);
for(i = 0;i < N;i++)
{
printf("%d ",array[i]);
}
printf("\n");
return 0;
}
void quick_sort(int* keys,int size)
{
if(size > 1)
quick_sort_impl(keys,0,size - 1);
}
void quick_sort_impl(int* keys,int left,int right)
{
int pivotkey;
int save_left,save_right;
save_left = left;
save_right = right;
pivotkey = keys[left];
while(left < right)
{
while(left < right && keys[right] > pivotkey) right--;
if(left < right)
{
keys[left] = keys[right];
left++;
}
while(left < right && keys[left] < pivotkey) left++;
if(left < right)
{
keys[right] = keys[left];
right --;
}
}
keys[left] = pivotkey;
if(save_left < left)
quick_sort_impl(keys,save_left,left-1);
if(save_right > left)
quick_sort_impl(keys,left+1,save_right);
}
5、归并排序