1.直接插入排序
算法思想：数组长度为N，从数组下标1处开始遍历，比较标为m的数组元素和下标从0—m-1的大小，插入形成一个有序的数组。
算法的实践复杂度O(N2)
程序范例：
</pre><pre name="code" class="cpp">void insert_direct(int a[],int n)
{
int temp,j;
for(int i =1; i<n;i++)
{
temp = a[i];
j=i-1;
while(j>=0&&a[j]>temp)
{
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}
2.希尔排序
基本思想：将排序列划分成若干组，在每组内进行直接插入排序，并逐步减少每次排序所用的步长，然后再对整个组进行直接插入排序。
算法复杂度O（nlogn）
下图程序中的步长是按照n/2的方法实现的，所以才会有如上的复杂度，如果是n-1的方法，则复杂度要增大。
程序范例：
void shell_sort(int a[],int n,int footlength)
{
int temp,k;
while (footlength>=1)
{
for(int i=0;i<footlength;i++)
{
for(int j=i+footlength;j<n;j=j+footlength)
{
if(a[j]<a[j-footlength])
{
temp = a[j];
k = j-footlength;
while(k>=0&&a[k]>temp)
{
a[k+footlength]=a[k];
k=k-footlength;
}
a[k+footlength]=temp;
}
}
}
footlength = footlength/2;
}
}3.冒泡排序
基本思想:从排序列的屁股开始，逐个比较两个元素，发现不符合序列则交换
，每次循环只能使一个气泡到位，所以一共要进行n次循环才能使排序列排序完成。
算法复杂度O(n2)
程序实例：
//冒泡排序
void bubble_sort(int a[],int n)
{
int temp;
for(int i=0;i<n;i++)
{
for(int j=n-1;j>i;j--)
{
if(a[j]<a[j-1])
{
temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
}4.快速排序
基本思想：
1）选定一个元素作为中间元素（一般是排序列的第一个元素）保存这个元素，则该元素所在的位置则出现了一个空位。
2）从排序列的末尾开始，找到一个比该元素小的，放在该元素所在的空位上，然后空位移到末尾相应的地方。
3）从排序列的前面找一个比该元素大的数，放在后面的空位上，空位前移。
4）反复直到两边的搜索部位重合，将该元素放到重合的部位上，则完成了一次排序，该元素前面的元素都比它小，后面的元素都比它大。
5）递归排序，最后可将整个排序列排序完成。
算法复杂度O(nlogn)
程序实例：
//对a[]数组中下标为head到rear的数组进行排序
void part(int a[],int head,int rear,int &cp)
{
int temp = a[head];
int i =head,j=rear;
while(i!=j)
{
while(i<j&&a[j]>temp)
{ j--;}
if(i<j)
{
a[i]=a[j];
i+=1;
}
while(i<j&&a[i]<temp)
{i++;}
if(i<j)
{
a[j]=a[i];
j-=1;
}
}
a[i]=temp;
cp=i;
}
//递归快速排序
void quick_sort(int a[],int head,int rear)
{
int i;
if(head<rear)
{
part(a,head,rear,i);
quick_sort(a,head,i-1);
quick_sort(a,i+1,rear);
}
}
5.直接选择排序
基本思想：在每一次的排序中，选定开始的元素下标为最（大）小值下标，然后向后搜索，如果比它小（大）则把最小的下标换成相应元素对应的下标，最后如果下标不是初始下标，则将不同的下标所对应的元素交换。最终完成排序。
算法复杂度：O(N2)
程序示例：
//直接选择排序
void select_sort(int a[],int n)
{
int mi,temp;
for(int i=0;i<n-1;i++)
{
mi=i;
for(int j=i+1;j<n;j++)
{
if(a[j]<a[mi])
mi=j;
}
if(mi!=i)
{
temp=a[i]; a[i]=a[mi]; a[mi]=temp;
}
}
}
6.归并排序
基本思想：
1）归并：将两个排序列合成一个新的有序列，对排序列AB分别从初始扫描，当A的元素大于B的元素时先插入A中元素，A中搜索向前进一，以此类推，最终形成一个新的有序数列C。
2）归并排序：利用递归的方法将一个排序列排序。先将排序列看成事N个有序子表，每个字表的长度为1，然后两两归并，得到n/2个有序子表，依次递归，最后得到有序的一个排序列。
算法复杂度：O(nlogn)
程序实例;
//归并排序
//一次归并
void merged(int a[],int p,int q,int r)
{
int n1= q-p+1;
int n2 = r-q;
int *L = new int[n1+1];
int *R = new int[n2+1];
int i,j,k;
for(i=0;i<n1;i++)
{
L[i]=a[p+i];
}
for(j=0;j<n2;j++)
{
R[j]=a[q+j+1];
}
L[n1]=R[n2]=9999999;
for(i=0,j=0,k=p;k<=r;k++)
{
if(L[i]<=R[j])
{
a[k]=L[i];
i++;
}
else
{
a[k]=R[j];
j++;
}
}
}
//归并排序
void merged_sort(int a[],int p,int r)
{
int q;
if(p<r)
{
q=(p+r)/2;
merged_sort(a,p,q);
merged_sort(a,q+1,r);
merged(a,p,q,r);
}
}