插入排序：简单地说，就是就将无序序列依次插入到有序序列中。
算法描述：
1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5
时间复杂度：
最坏情况；O(n^2);
平 均：O(n^2);
/*********** 插入排序 ************/
void InsertSort(int *p, const int len)
{
assert(p != NULL);
int i;
int j;
int temp;
for (i = 1; i < len; i++)
{
temp = p[i];
for (j = i-1; j >= 0; j--)
{
if (p[i] > temp)
{
p[j+1] = p[j];
}
else
{
break;
}
}
p[j+1] = temp;
}
}
冒泡排序：
一种简单地排序算法。
算法描述：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这样会使得最后的元素为最大值；
3. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
时间复杂度：
最坏情况；O(n^2);
平 均：O(n^2);
/*********** 冒泡排序 ************/
void BubbleSort(int *p, const int len)
{
assert(p != NULL);
int i;
int j;
int temp;
for (i = 0; i < len; i++)
{
for (j = 0; j < len-i-1; j++)
{
if (p[j] > p[j+1])
{
temp = p[j];
p[j] = p[j+1];
p[j+1] = temp;
}
}
}
}
/*********** 冒泡排序 ************/
void BubbleSort(int *p, const int len)
{
assert(p != NULL);
int i;
int j;
int temp;
for (i = 0; i < len; i++)
{
for (j = i+1; j < len; j++)
{
if (p[i] > p[j])
{
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
}
选择排序：从未排序列中找到最大（小）元素将其置于合适的位置。
算法描述：
1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
2. 从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。
3. 重复步骤2，直到所有元素均排序完毕。
时间复杂度：
最坏情况；O(n^2);
平 均：O(n^2);
/*********** 选择排序 ************/
void SelectSort(int *p, const int len)
{
assert(p != NULL);
int i;
int j;
int k;
int temp;
for (i = 0; i < len-1; i++)
{
k = i;
for (j = i+1; j < len; j++)
{
if (p[k] > p[j])
{
k = j;
}
}
if (k != i)
{
temp = p[i];
p[i] = p[k];
p[k] = temp;
}
}
}
快速排序：通过一趟排序将待排记录分隔成独立的两部分，其中以部分记录的关键字比另一部分记录的关键字小，
则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法描述：
1. 设置两个变量low、high，排序开始的时候：low=0，high=N-1；
2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3. 从high开始向前搜索，即由后开始向前搜索(high--)，找到第一个小于key的值p[high]，将值为key的项与p[high]交换；
4. 从low开始向后搜索，即由前开始向后搜索(low++)，找到第一个大于key的p[low]，将值为key的项与p[low]交换；
5. 重复第3、4、5步，直到low=high； (3,4步中，没找到符合条件的值，即3中p[high]不小于key,4中p[low]不大于key的时候改变low、high的值，使得high=high-1，low=low+1，直至找到为止。找到符合条件的值，进行交换的时候low，high指针位置不变。另外，low==high时令循环结束）。
时间复杂度：
最坏情况：O(n^2);
平 均：O(nlogn);
/*********** 调整分区 ************/
int Partition(int *p, const int low, const int high)
{
assert(p != NULL);
int i = low;
int j = high;
int key = p[low];
while (i < j)
{
while (i < j && key <= p[j])
{
j--;
}
if (i < j)
{
p[i++] = p[j];
}
while (i < j && key > p[i])
{
i++;
}
if (i < j)
{
p[j--] = p[i];
}
}
p[i] = key;
return i;
}
/*********** 快速排序 ************/
void QuickSort(int *p, const int low, const int high)
{
assert(p != NULL);
int pos = Partition(p, low, high);
if (low < high)
{
QuickSort(p, low, pos-1); // 递归地对关键字前面的序列进行排序
QuickSort(p, pos+1, high); // 递归地对关键字后面的序列进行排序
}
}
堆排序：是指利用堆这种数据结构所设计的一种排序算法。
算法思想：
1. 初始化操作：将R[1..n]构造为“大顶堆”；
2. 将当前无序区的堆顶记录R[0]和该序列的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)；
3. 直到所有元素有序；
时间复杂度：
最坏情况；O(nlogn);
平 均：O(nlogn);
/*********** 构建大顶堆 ************/
void AdjustTop(int *p, const int len)
{
assert(p != NULL);
int pos = len / 2 - 1;
int t;
int temp;
while (pos >= 0)
{
if (pos*2+2 == len) // 只有自由左子树的情况
{
t = p[pos*2+1] > p[pos] ? pos*2+1 : pos;
}
else // 左右子树都存在
{
t = p[pos*2+1] > p[pos*2+2] ? pos*2+1 : pos*2+2;
t = p[t] > p[pos] ? t : pos;
}
if (t != pos) // 加此条件判断以减少交换次数
{
temp = p[pos];
p[pos] = p[t];
p[t] = temp;
}
pos--;
}
}
/*********** 堆排序 ************/
void HeapSort(int *p, const int len)
{
assert(p != NULL);
int i;
int temp;
for (i = 0; i < len; i++)
{
AdjustTop(p, len-i); //对剩余元素重新构建“大顶堆”
temp = p[0];
p[0] = p[len-i-1];
p[len-i-1] = temp;
}
}
各种内部排序方法的比较：
1. 就平均时间性能而言，快速排序最佳，其所需时间最少，但快速排序在最坏情况下的性能不如堆排序；
2. 由于堆排序在最坏情况下的时间复杂度和平均时间复杂度差不多，所以待排序列中元素初始时的顺序对该排序算法没有太大影响。
2. 从方法的稳定性来看，所有时间复杂度为O(n^2)的简单排序法都是稳定的（包括插入排序、冒泡排序、选择排序）。一般来说，排序过程中的“比较”是在“相邻的两个记录关键字”间进行的排序方法都是稳定的。