排序
总结一下排序的各类算法，包括冒泡排序、插入排序、快速排序，关于堆排序见博客：堆及其算法。
1.冒泡排序
冒泡排序是效率很低（n^2）的排序，一般情况下都不会使用的，在小数据时还可以考虑，不过没有见过算法库使用冒泡排序的，一般的算法库在小数据情况下使用插入排序。
冒泡排序的思想很简单，逆序两两交换，两层循环。
源码：
void BubbleSort1(int a[], int len)
{
if(len<2) return;
int i,j;
for(i=0;i<len;i++) //这个循环只是为了计数的
for(j=1;j<len-i;j++)
if(a[j]<a[j-1]) //这个表达式可以设定排序顺序
swap(a[j],a[j-1]);
}
优化：可以将swap函数展开以牺牲代码的简洁性来优化效率。其实直接定义为宏或者inline就可以了。
#dedine swap(a,b) a^=b^=a^=b
void BubbleSort2(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=0;i<len;i++) //这个循环只是为了计数的
for(j=1;j<len-i;j++)
if(a[j]<a[j-1])
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
2.插入排序
插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。插入排序的思想就好比是整理扑克牌，前段是有序区，后段无序区，为无序区的每一个元素在有序区选择合适的插入位置，然后有序区插入位置之后的元素循环后移1位(这里有点类似冒泡，所以也是两层循环)。
源码：
void InsertSort1(int a[], int len)
{
if(len<2) return;
int i,j;
for(i=1;i<len;i++)
for(j=i;j>0&&a[j]<a[j-1];j--)
swap(a[j],a[j-1]);
}
优化：1、可以将swap展开
void InsertSort2(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=1;i<len;i++)
for(j=i;j>0&&a[j]<a[j-1];j--)
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
继续优化：如果t在循环内部的话，是冒泡的效果，如果将t的复制提到循环外部的话，那么就是循环移位最后进行一次赋值就可以了。
void InsertSort3(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=1;i<len;i++)
{
t=a[i];
for(j=i;j>0&&a[j-1]>t;j--) //注意这里的判定条件，与InsertSort2进行比较
a[j]=a[j-1];
a[j]=t;
}
}
继续优化：先比较首尾元素，因为最小元素必须在首端，如果尾端元素小于首端元素，那么不如一次做完拉倒（这是STL中的方式）。
void InsertSort4(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
if(a[0]>a[len-1]) //头比尾还小
swap(a[0],a[len-1]);
for(i=1;i<len;i++)
{
t=a[i];
for(j=i;j>0&&a[j]<a[j-1];j--)
a[j]=a[j-1];
a[j]=t;
}
}
3.快速排序
快速排序的基本思想是：首先先从数列中取出一个数作为基准数。然后进行分区，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。再对左右区间重复第二步，直到各区间只有一个数。
但是关于快速排序的实现有不同的方式，当然考虑越多效率越高。
首先来看单端遍历的快速排序版本：
//该版本将首端元素作为主元
void QuickSort1(int a[],int len)
{
if(len<2) return;
int i,m=0; //i用于遍历数组，m标记位置，指向最后一个小于key的值
data_type key=a[0];
for(i=1;i<=len;i++)
{
if(a[i]<key)
swap(a[++m],a[i]);
}
swap(a[m],a[0]);
QuickSort1(a,m);
QuickSort1(a+m+1,len-m-1);
}
优化：可以进行双端的搜寻，左端向右搜寻，直至所指元素值大于主元时停止，右端向左搜寻，直至所指元素值小于主元时停止，然后交换搜寻到的两值。搜寻过程中一直检测指针是否交叉。
void QuickSort2(int a[],int len)
{
if(len<2) return;
int i=0; //i，j分别为前后段搜索标号，注意这里i和j的初值
int j=len; //因为后面使用的是do-while语句
data_type key=a[0];
for(;;)
{
do i++; while(i<(len-1)&&a[i]<key);
do j--; while(j>0&&a[j]>key);
if(i>=j) break; //这里必须是>=相等的时候必须返回，如果不返回，开始另外的一轮循环，j的位置就不对了
swap(a[i],a[j]);
}
swap(a[0],a[j]);
QuickSort2(a,j);
QuickSort2(&a[j+1],len-j-1);
}
优化：接下来需要考虑的是主元的选择方式，如果主元选a[0]的话，那么算法的效率将与数据的排列方式有很大的关系，为了获得平均复杂度，需要引入随机性。有两种方式，一种随机性弱点的是三端法，选取首中尾端三个元素的中值作为主元；另外一种是引入一个随机函数randint来选择主元的标号。选好主元之后要将主元交换到首端。
最后的优化是对快速排序缺陷的避免，因为快速排序在小数据上的效果不太理想。而且经过快速排序数据将分为很多段逆序数小的小数据段。对这种小数据段，应用插入排序效果更好。所以引入一个阀值cutoff（STL标准定义为__stl_threshold=16），当数据段的长度小于等于该阀值的时候对该数据段进行插入排序。对于不同的机器，阀值的大小是不一样的，可以进行测定。
还能附加一点就是SGI版本的STL特有的优化，防止过多次数的分割，也就是迭代次数不能过多。
void Sort(int a[],int len)
{
if (len<8) //阀值选为8
InsertSort3(a,len);
else
{
int k=rand()%len;
swap(a[0],a[k]); //这里运用随机的方式选取主元
int i=0;
int j=len;
int key=a[0];
for(;;)
{
do i++; while(i<(len-1)&&a[i]<key);
do j--; while(a[j]>key);
if(i>j) break;
swap(a[i],a[j]);
}
swap(a[0],a[j]);
Sort(a,j);
Sort(a+j+1,len-j-1);
}
}
5.归并排序
归并排序是要开辟O(n)的空间的，每一次处理归和并都需要传入该空间（地址）。
注意下面代码的函数接口！！！！
void merge(int a[],int begin,int mid,int end,int temp[])
{
int i=begin,j=mid+1;
int k=0;
while(i<=mid&&j<=end)
{
if(a[i]<a[j])
temp[k++]=a[i++];
else
temp[k++]=a[j++];
}
if(i>mid)
while(j<=end)
temp[k++]=a[j++];
else
while(i<=mid)
temp[k++]=a[i++];
for(i=0;i<k;i++)
a[begin+i]=temp[i];
}
void mergesort(int a[],int begin,int end,int temp[])
{
if(end>begin)
{
int mid=begin+(end-begin)/2;
mergesort(a,begin,mid,temp);
mergesort(a,mid+1,end,temp);
merge(a,begin,mid,end,temp);
}
}
void MergeSort(int a[],int len)
{
if(a==NULL||len<1)
return;
int *p=new int[len];
mergesort(a,0,len-1,p);
delete [] p;
}
5.1单链表的排序
一般数组排序用快速排序，而链表排序用归并排序。因为因为无法向前寻找节点，所以插入排序不适用，冒泡排序需要稍微的修改，但是O(n^2)的复杂度不佳。快速排序只能用单端的模式。如果使用归并排序的话，链表还可以避免归并排序开辟O(n)空间的缺点，并且是对数时间完成排序！
而单链表的归并排序中一般归的步骤使用递归的，而并的步骤可以选用递归也可以选用非递归。当然选非递归的更加好。其实链表的归并排序依然是归并的思想，对于链表而言，特殊性在于参数为链表头结点。所以需要寻找到链表的中间结点，故用快慢指针！！并且中间结点在归的过程中需要将right设置为NULL，这样才能将两个链表分开！
typedef struct LNode
{
int data;
struct LNode *next;
}LNode;
typedef LNode* LinkList;
// 对两个有序的链表进行递归的归并
LinkList MergeList_recursive(LinkList head1 , LinkList head2)
{
LinkList result;
if(head1 == NULL)
return head2;
if(head2 == NULL)
return head1;
if(head1->data < head2->data)
{
result = head1;
result->next = MergeList_recursive(head1->next , head2);
}
else
{
result = head2;
result->next = MergeList_recursive(head1 , head2->next);
}
return result;
}
// 对两个有序的链表进行非递归的归并
LinkList MergeList(LinkList head1 , LinkList head2)
{
LinkList head , result = NULL;
if(head1 == NULL)
return head2;
if(head2 == NULL)
return head1;
while(head1 && head2)
{
if(head1->data < head2->data)
{
if(result == NULL)
{
head = result = head1;
head1 = head1->next;
}
else
{
result->next = head1;
result = head1;
head1 = head1->next;
}
}
else
{
if(result == NULL)
{
head = result = head2;
head2 = head2->next;
}
else
{
result->next = head2;
result = head2;
head2 = head2->next;
}
}
}
if(head1)
result->next = head1;
if(head2)
result->next = head2;
return head;
}
// 归并排序，参数为要排序的链表的头结点，函数返回值为排序后的链表的头结点
LinkList MergeSort(LinkList head)
{
if(head == NULL)
return NULL;
LinkList r_head , slow , fast;
r_head = slow = fast = head;
while(fast->next != NULL && fast->next->next != NULL)
{
slow = slow->next;
fast = fast->next->next;
}
if(slow->next == NULL) // 链表中只有一个节点
return r_head;
fast = slow->next;
slow->next = NULL;
slow = head;
// 函数MergeList是对两个有序链表进行归并，返回值是归并后的链表的头结点
//r_head = MergeList_recursive(MergeSort(slow) , MergeSort(fast));
r_head = MergeList(MergeSort(slow) , MergeSort(fast));
return r_head;
}