在没有特殊说明的情况下，默认排序结果是升序。
1、插入排序
1.1 直接插入排序算法
对于直接插入排序，设A[n]是一个有n个数的待排序数组，现假设要排序的位置是i，其执行的过程为（第0号位置不适用，从1号开始）：
1、首先保存第i号元素，把第i号元素放在第0号位置，充当哨兵的作用，这样可以减少循环条件，相对来说会优化一点点；
2、1— i-1位置的元素都已排好序，将第i个位置的元素与前i-1个元素依次比较，直到找到小于等于自己的元素停止，假设位置是k。
3、将第k+1—i-1位置上的所有元素后移，空出的第k+1个位置放第i个元素。
具体代码：
//直接插入排序
void InsertSort(int a[],int n)
{
int j;
for(int i=2;i<=n;i++)
{
if(a[i]<a[i-1]) //当前元素比其前驱小，将a[i]插入有序表中
{
a[0]=a[i]; //保存当前元素，充当哨兵
for(j=i-1;a[j]>a[0];j--) //从后往前寻找待插入位置
{
a[j+1]=a[j]; //向后移动
}
a[j+1]=a[0]; //将第i个元素插入
}
}
}空间复杂度：O(1)；
时间复杂度：
最好情况：O(n)； //原始表中有序，每次插入一个元素，只需要比较一次，而无需移动；
最坏情况：O(n)； //原始表也是有序，但是是逆序。总的比较次数达到最大，移动次数也达到最大。
平均时间复杂度：O(n^2)；
稳定性：每次都是从后往前移动元素，不会出现相同元素相对位置发生变化的情况，稳定。
直接插入排序即适合顺序存储，也适合链式存储的线性表。但是链式存储只是减少了移动的次数，比较的次数仍然回达到平方的数量级，时间复杂度仍然是平方级。
但其适用于待排序元素基本有序。
1.2 折半插入排序
折半插入排序是针对直接插入排序算法的一个小改进，其改进之处在于，由于在插入第i个元素时，前i-1个元素是排好序的，所以在查找这步中，我们可以使用折半查找，找到待插入位置，然后再移动。
具体代码：
//折半插入排序
void InsertSort(int a[],int n)
{
int i,j,low,high,mid;
for(i=2;i<=n;i++)
{
a[0]=a[i];
low=1,high=i-1;
while(low<=high) //折半查找的思想，寻找待插入位置
{
mid=(low+high)/2;
if(a[mid]<=a[0])
{
low=mid+1;
}
else
high=mid-1;
}
for(j=i-1;j>=high+1;j--) //将low —i-1位置的元素后移
{
a[j+1]=a[j];
}
a[high+1]=a[0]; //插入到low的位置
}
}时间复杂度：折半查找虽然减少了比较的次数，但是移动的次数还是没变，因此，折半查找的时间复杂度仍为O(n^2)；
折半查找在处理的时候，特别注意了元素值相等的情况，当a[mid]=a[i]的时候，我们继续往后寻找合适的位置，这样做的好处就是可以保证插入排序的稳定性。
2、希尔排序
希尔排序是针对直接插入排序的一种改进。因为直接排序在数组相对有序的情况下，时间复杂度比较小，所以希尔排序的思想就是：先将待排序表分割成若干个形如：a[i，i+d，i+2d……]的“特殊”子表，即把相隔某个增量的记录组成一个子表，对各个子表分别进行直接插入排序，当整个表中的元素都呈现出“基本有序”时，再对全体记录进行一次直接插入排序。
其实希尔排序只不过是增加了一个增量，每次比较的是同一增量的元素，每轮排序完成后，增量减半，但是其基本思想就是直接插入排序。要注意希尔排序的移动的判定条件。
具体代码：
//希尔排序
void ShellSort(int a[],int n)
{
int d; //增量
for(d=n/2;d>=1;d/=2) //不断缩短增量排序
{
for(int i=d+1;i<=n;i+=d) //前面元素是排好序的，从d+1开始
{
if(a[i]<a[i-d])
{
a[0]=a[i]; //这里的a[0]不是起到哨兵的作用，只是保存第i个元素
for(int j=i-d;j>0&&a[0]<a[j];j-=d) //注意判定条件，将同一个子表中符合条件的元素后移
{
a[j+d]=a[j];
}
a[j+d]=a[0]; //插入元素
}
}
}
} 时间复杂度：最坏情况下（当d取1时：O(n)；当n在某个特定范围时，时间复杂度约为：O(n^1.3)。
通过排序过程可以看出，希尔排序是个不稳定的排序算法。并且由于它需要使用增量d找到属于同一个子表的元素，所以它不能使用链表这种不具备随机访问特性的存储结构。
3、冒泡排序
冒泡排序是一种基于交换的思想，每一趟排序将最大值或者最小值排到前面，每一趟结束后， 每一个位置的元素就是其最终所在的位置。
//冒泡排序
void BubbleSort(int a[],int n)
{
for(int i=0;i<n-1;i++)
{
bool flag=false; //表示本趟冒泡排序是否发生交换的标志
for(int j=0;j<n-1-i;j++)
{
if(a[j]>a[j+1]) //若逆序
{
swap(a[j],a[j+1]); //则交换
flag=true;
}
}
if(flag==false) //本趟遍历没有发生交换，说明已经有序
return ;
}
}4、快速排序
快速排序是基于分而治之的思想：每一次在待排序的表中选择一个数作为基准，通过一趟排序将待排序表划分为两个部分，每一次排完序，比基准小的元素都在左边，比基准大的元素都在右边，然后左右两边递归进行排序，直到每个部分只有一个元素或者为空位为止。
在该代码中，假设每次都以第一个元素作为基准进行划分。
具体代码：
#include <iostream>
using namespace std;
int s[100];
int Partition(int a[],int low,int high)
{
int p=a[low]; //选择基准元素
while(low<high)
{
while(low<high&&a[high]>=p) //把基准后面比基准大的元素往前移
high--;
a[low]=a[high];
while(low<high&&a[low]<p) //把基准前面比基准小的元素往后移
low++;
a[high]=a[low];
}
a[low]=p; //把基准放在最终位置
return low; //返回基准位置
}
void QuickSort(int a[],int low,int high)
{
if(low<high)
{
int mid=Partition(a,low,high);
QuickSort(a,low,mid-1); //对每次划分的前后部分分别递归处理
QuickSort(a,mid+1,high);
}
}
int main(int argc, char** argv) {
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>s[i];
QuickSort(s,0,n-1);
for(int i=0;i<n;i++)
{
cout<<s[i]<<" ";
}
return 0;
}可以看出，快速排序的算法关键在于划分，那么该算法的性能也就主要取决于划分操作的好坏。快速排序需要利用递归进行，所以需要一个递归工作栈作为辅助空间。
空间复杂度就是该栈所需的空间，最好情况下是：O(logn)；最坏的情况就是表基本有序或者基本逆序。空间复杂度为O(n)；平均空间复杂度为:O(logn)；
时间复杂度：最好的情况下：O（nlogn)；最坏的情况下：O(n)；
可以推算出，快排是一种不稳定的算法。
虽然快排每次排序后并不产生有序子序列，但是每次排序后都会把基准放到其最终位置上。
5、选择排序
5.1 简单选择排序
算法思想：每一趟排序都是在待排序元素中选取关键字最小（或最大）的元素加入到有序子序列中。
具体代码：
//简单排序
void SelectSort(int a[],int n)
{
for(int i=0;i<n-1;i++) //n个元素需要n-1趟排序
{
int min=i;
for(int j=i+1;j<n;j++) //每次都是寻找最小值
{
if(a[j]<a[min])
min=j;
}
if(min!=i) //若找到最小值，交换
swap(a[i],a[min]);
}
} 空间复杂度：O(1)；
时间复杂度：O(n*n)；
该算法不稳定，但其既适用于顺序表，又使用于链表。
5.2 堆排序
堆排序是一个性能比较优秀的算法，它也是基于选择排序的思想，大顶堆：在完全二叉树中，根>=左右结点。小顶堆刚好相反。
堆排序分为：建堆和输出堆顶元素，再继续调整堆。
建堆过程（以大顶堆为例）：从完全二叉树中的最后一个非终端结点，也就是第n/2个结点 开始，若该结点存在左右孩子，则判断该结点的左右孩子是否比根结点大，若是，则选择最大的一个孩子结点和根结点互换，但是互换后可能会破坏其孩子结点的堆，所以继续采用刚才方法构造下一级堆，直到以该结点为根的子树构成大顶堆为止。
排序过程（以大顶堆为例）：每一趟排序将堆顶元素加入到有序子序列（与待排序元素序列中的最后一个元素交换），并将待排序元素序列再次调整为大顶堆。
大顶堆的具体代码：
#include <iostream>
using namespace std;
int s[100];
//大根堆排序
void HeadAdjust(int a[],int k,int len)
{
a[0]=a[k]; //先把第k个元素存着，以期后面找到合适的位置放置
for(int i=2*k;i<=len;i*=2) //顺着k较大的子结点向下筛选
{
if(i<len&&a[i]<a[i+1]) //i<len保证有右孩子，在左孩子和右孩子中选一个最大
{
i++;
}
if(a[0]>=a[i]) //根结点本身就是最大
break;
else
{
a[k]=a[i]; //根结点替换为最大的孩子
k=i; //孩子结点的大顶堆有可能被破坏，所以沿着k的孩子结点往下判断
}
}
a[k]=a[0]; //被筛选结点的值放入最终位置
}
void BuiltMaxHeap(int a[],int len)
{
for(int i=len/2;i>=1;i--) //从最后一个非终端结点到根结点调整堆
{
HeadAdjust(a,i,len);
}
}
void HeapSort(int a[],int len)
{
BuiltMaxHeap(a,len); //先建堆
for(int i=len;i>1;i--) //n个元素需要进行n-1趟排序
{
swap(a[i],a[1]); //和堆低元素交换，将最大值后移，实现升序
HeadAdjust(a,1,i-1);
}
}
int main(int argc, char** argv) {
int n;
cin>>n;
for(int i=1;i<=n;i++)
cin>>s[i];
HeapSort(s,n);
for(int i=1;i<=n;i++)
{
cout<<s[i]<<" ";
}
return 0;
}小顶堆的分析过程和大顶堆类似，所以，这里直接给出代码。需要注意的是：基于大顶堆的排序是升序，基于小顶堆的排序是降序。
小顶堆的具体代码：
#include <iostream>
using namespace std;
int s[100];
//小根堆排序
void HeadAdjust(int a[],int k,int len)
{
a[0]=a[k]; //先把第k个元素存着，以期后面找到合适的位置放置
for(int i=2*k;i<=len;i*=2) //顺着k小的子结点向下筛选
{
if(i<len&&a[i]>a[i+1]) //i<len保证有右孩子，在左孩子和右孩子中选一个最小
{
i++;
}
if(a[0]<=a[i]) //根结点本身就是最小
break;
else
{
a[k]=a[i]; //根结点替换为最小的孩子
k=i; //孩子结点的小顶堆有可能被破坏，所以沿着k的孩子结点往下判断
}
}
a[k]=a[0]; //被筛选结点的值放入最终位置
}
void BuiltMinHeap(int a[],int len)
{
for(int i=len/2;i>=1;i--) //从最后一个非终端结点到根结点调整堆
{
HeadAdjust(a,i,len);
}
}
void HeapSort(int a[],int len)
{
BuiltMinHeap(a,len); //先建堆
for(int i=len;i>1;i--) //n个元素需要进行n-1趟排序
{
swap(a[i],a[1]); //和堆低元素交换，将最小值后移，实现降序
HeadAdjust(a,1,i-1);
}
}
int main(int argc, char** argv) {
int n;
cin>>n;
for(int i=1;i<=n;i++)
cin>>s[i];
HeapSort(s,n);
for(int i=1;i<=n;i++)
{
cout<<s[i]<<" ";
}
return 0;
}空间复杂度：O（1）；
时间复杂度为：最好，最坏和平均都是O(nlogn)；
可以推算出该算法是不稳定的。
6、归并排序
归并排序的算法思想：将待排序表中的n个记录视为有n个有序的子表，但是每个子表的长度为1，然后两两归并，得到n/2向上取整个长度为1或2的有序表，继续两两归并，如此重复，直到合并为一个长度为n的有序表为止，这就是2路归并排序。
具体代码：
#include <bits/stdc++.h>
using namespace std;
#define n 100
int s[n];
int *b=(int *)malloc(sizeof(int)*(n+1)); //辅助数组B
int i,j,k;
void Merge(int a[],int low,int mid,int high)
{
for(k=low;k<=high;k++) //先将表中数据复制到辅助数组中
{
b[k]=a[k];
}
for(i=low,j=mid+1,k=i;i<=mid&&j<=high;)
{
if(b[i]<=b[j])
{
a[k++]=b[i++];
}
else
{
a[k++]=b[j++];
}
}
while(i<=mid) //其中有一个表中还有数据
a[k++]=b[i++];
while(j<=high)
a[k++]=b[j++];
}
void MergeSort(int a[],int low,int high)
{
if(low<high)
{
int mid=(low+high)/2; //从中间划分两个子序列
MergeSort(a,low,mid); //对左侧子序列进行递归排序
MergeSort(a,mid+1,high); //对左侧子序列进行递归排序
Merge(a,low,mid,high); //归并
}
}
int main(int argc, char** argv) {
int m;
cin>>m;
for(int i=1;i<=m;i++)
{
cin>>s[i];
}
MergeSort(s,1,m);
for(int i=1;i<=m;i++)
cout<<s[i]<<" ";
return 0;
}归并排序的核心操作是：把数组 内的两个有序序列归并为一个。
空间复杂度：O（n）；虽然递归也需要空间，但是归并树可以看成是一个倒立的二叉树。递归深度<logn；
时间复杂度：O(nlogn)。
7、基数排序
基数排序不是基于比较和移动的思想，而是基于关键字各位的大小进行排序。
基数排序的基本思想（以递减序列为例）：
1、初始化：设置r个空队列，Qr-1,Qr-2,……，Q0，按照各个关键字位权重递减的次序（个、十、百），对d各关键字位分别做“分配” 和“收集”。
2、分配：顺序扫描各个元素，若当前处理的关键字位=x，则将元素插入Qx队尾。
3、收集：把Qr-1，Qr-2，……，Q0各个队列中的结点依次出队并链接。
空间复杂度：由于基数排序是用链式存储。需要辅助空间r个队列。所以时间复杂度为O（r)。
时间复杂度：O（d(n+r)）；基数排序需要进行d趟分配和收集，一趟分配需要O（n），一趟收集需要O（r）。
可以推算出：基数排序是稳定的。