一：排序分类
二、算法实现（内部排序）
1、插入排序之直接插入排序
排序步骤：
①从第一个元素开始，该元素可以认为已经被排序
②取出下一个元素，在已经排序的元素序列中从后向前扫描
③如果该元素小于前面的元素（已排序），则依次与前面元素进行比较如果小于则交换，直到找到大于该元素的就则停止；
④如果该元素大于前面的元素（已排序），则重复步骤2
重复步骤2~4 直到所有元素都排好序
例：3 4 7 1 5 2 6 9（排成递增序列）
排序过程：i = 1：3 4 7 1 5 2 6 9 （3和4比）
i = 2：3 4 7 1 5 2 6 9 （4和7比）
i = 3：①3 4 1 7 5 2 6 9（1和7比）
②3 1 4 7 5 2 6 9（1 和4比）
③1 3 4 7 5 2 6 9（1和3比）
......
i = 8:1 2 3 4 5 6 7 9
使用直接插入排序的优点是稳定，快速，缺点是：比较次数不一定，比较次数越多，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。平均时间复杂度O（n^2）,适合于量级小于千的排序。
清单1：
int StraightInsertSort(int s[],int n)
{
int i,j;
int temp;
for(i = 1;i<n;i++)
{
for(j = i; j > 0;j--)
{
if(s[j] < s[j-1])
{
temp = s[j];
s[j] = s[j-1];
s[j-1] = temp;
}
else
break;
}
}
}
2、插入排序之希尔排序
原理：已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大时，插入排序的效果很好。首先取一增量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以此类推，在各组内用插入排序，然后取d'<d，重复上述操作，直到d=1。
优点：快，数据移动少
缺点：d值不确定，取什么值看经验
希尔排序的时间复杂度为 O(N*(logN)2)，适合于中等规模排序
清单2：
int sheelsort(int a[],int n)
{
int k = n / 2;//k是增量
while (k > 0)
{
for (int i = k; i < n; i++)
{
int t = a[i];
int j = i - k;
while (j >= 0 && t < a[j])
{
a[j + k] = a[j];
j = j - k;
}
a[j + k] = t;
}
k /= 2;
}
}
3.选择排序之简单选择排序
①从左至右遍历，找到最小(大)的元素，然后与第一个元素交换。
②从剩余未排序元素中继续寻找最小（大）元素，然后与第二个元素进行交换。
③以此类推，直到所有元素均排序完毕。
有序区，无序区
int selectionsort(int a[],int n)
{
int i,j,temp;
//一趟一趟的找
for(i = 0; i < n;i++)
{
int min = i;
//找最小值，记录位置
for(j = i+1; j < n; j++)
{
if(a[min] > a[j])
min = j;
}
//找到后交换值
temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
4.堆排序
示例：
5、冒泡排序
一组数据，两两比较，大的放后面，小的放前面，就像冒泡一样，越大的泡会冒到最上面，一趟一趟比较，直到所有数据从小到大依次排列。
算法分析：
①相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
②平均时间复杂度o(n^2)
清单5：
int Bubblesort(int a[],int n)
{
int i,j,min;
for(j = 1; j < n; j++) //控制排序的执行次数
{
for(i = 0; i < n-j; i++) //控制在一次排序中相邻记录的比较和交换
{
if(a[i] > a[i+1]) //如果前面元素大于后面元素则交换
{
min = a[i+1];
a[i+1] = a[i];
a[i] = min;
}
}
}
}
6、快速排序
快速排序又叫分区交换排序，是目前已知的平均速度最快的一种排序方法。基本思想：从待排序的n个记录中任意选取一个记录Ri(通常选取序列中的第一个记录)做标准，调整序列中各个记录的位置，使排在Ri前面的记录的关键字都小于Ri.key,排在Ri后面的记录的关键字都大于等于Ri.key，我们把这样的一个过程称作一次快速排序。在第一次快速排序过程中，确定了所选取的记录Ri最终在序列中的排列位置，同时也把剩余的记录分成了两个子序列。对两个子序列分别进行快速排序，又确定了两个记录在序列中应处的位置，并将剩余记录分成了四个子序列，如此重复下去，当各个子序列的长度为一时，全部记录排序完毕。
算法分析：
①是一种不稳定的排序方法
②递归形式的快速排序法需要栈空间暂存数据，其空间复杂度为O（n）
③时间复杂度是o(nlgn)
清单6：
int quicksort(int a[],int low,int high)
{
int i,j,temp;
i = low;
j = high;
temp = a[i];
while(i < j)
{
//从右向左找第一个比temp小的元素
while(i < j && temp <= a[j]) //如果满足此条件，即temp的值比a[j]小
j--; //则j向左移动
if(i < j) //当不满足while循环的条件，即找到了一个比temp小的数，只要i<j，
{
a[i++] = a[j]; //将找到的小的数a[j]的值赋给a[i],i = i+1
}
//同理从左向右找第一个比temp大的元素
while(i < j && temp >= a[i]) //如果满足此条件，即temp的值比a[i]大
i++; //则i向右移动
if(i < j) //当不满足while循环的条件，即找到了一个比temp大的数，只要i<j，
{
a[j--] = a[i]; //将找到的大的数a[i]的值赋给a[j],j = j-1
}
a[i] = temp;
//使用递归实现子序列的排序
if(low < i)
{
quicksort(a,low,i-1);
}
if(i < high)
{
quicksort(a,j+1,high);
}
}
}
7、归并排序
8、基数排序
总结：
待续~~