快速排序
http://m.blog.csdn.net/blog/u013071074/36867589
快速排序是由C. A. R. Hoare所发展的一种排序算法。其基本思想是基本思想是，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
快速排序使用分治法来把一个串（list）分为两个子串行（sub-lists）。
步骤为：
1、从数列中挑出一个元素，称为 "基准"（pivot），
2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
最差时间复杂度：O(n^2)
最优时间复杂度：O(n log n)
平均时间复杂度：O(n log n)
最差空间复杂度：根据实现的方式不同而不同
算法理解
此排序算法， 思想是分治和筛选：
选择一个元素作为分割点， 将链表中分割成两个部分， 第一部分（比分割点小的部分）， 第二部分（比分割点大的部分）
所以整个链表分为三个部分： 分割点、 第一部分、第二部分。
然后对于第一部分 和 第二部分， 分别执行此筛选方法（递归执行）， 直到递归到 链表中只有一个元素。
形象点比喻， 有一筐柿子， 选取一个中等个头的柿子， 以此为标准， 将这堆柿子筛进去两个筐， 第一个筐中柿子的个头都比标准小， 第二个筐中柿子的个头都比标准大，
然后对分出来的两个筐， 分别执行相同的筛选， 到最后会形成， 一个筐中装一个柿子的情况， 这种情况也是递归的终止条件， 不需要继续筛选了。
算法的精髓是， 按照标准筛选：
1、 确定链表头一个元素作为标准值， 从表尾开始向前找到第一个一个小于此标准值的元素A， 与表头元素交换， （这样能够保证， A元素之后的元素都是大于标准值的）。
2、 第一步执行完毕后， 则标准元素的位置 变为 原来元素A的位置（即， 表尾第一个小于标准值的元素位置）， 则从第二个元素 到 标准元素的位置 之前， 可能还是有 大于标准值的元素， 我们需要找出来， 让此元素换到标准元素的右边， 即执行： 从第二个元素开始找到第一个大于标准值的元素B， 换到标准元素位置（这样能够保证， B元素之前的元素都是小于标准值的）。
3、 对于 中间部分未经筛选过的元素链表 （此时， 其第一个元素为 标准元素）， 同样执行 步骤 1 和 2。可以循环执行、或者递归执行， 终止条件都是 未筛选部分链表长度为 1， 即 只有一个元素。
总体思路是， 将右边的比标准值小的 元素 换到 左边， 将左边的比标准值大的元素 换到 右边。 目的是， 将链表分成两个部分， 左边小（比标准）， 右边大（比标准）。
事实上可以这么理解， 从第一个元素开始向右边找到第一个比标准值大的元素， 然后从最后一个元素开始向左边找到第一个小于标准值的元素， 然后交换两者，
然后对未筛选的区间， 递归执行此帅选， 直到此区间长度为1。
C代码实现
完整代码如下URL
https://github.com/fanqingsong/code-snippet/blob/master/C/QuickSort/quicksort.c
下面给出核心code
移植list api后， 基于list实现的链表排序核心代码：
/***********************************************************************
QuickSort function
************************************************************************/
// list quick sort core function
void _List_QuickSort(PT_LIST_LINKNODE ptLinkFirst, PT_LIST_LINKNODE ptLinkLast)
{
// center node that will partion list into two part,
// left nodes all are less than it,
// right nodes all are greater than it
PT_LIST_LINKNODE ptLinkPivot = NULL;
char* szPivot = NULL;
// the left and right cursor used in one comparing procedure
PT_LIST_LINKNODE ptLinkLeft = NULL;
PT_LIST_LINKNODE ptLinkRight = NULL;
PT_NODE ptNodePivot = NULL;
PT_NODE ptNodeLeft = NULL;
PT_NODE ptNodeRight = NULL;
// recurse to the ceasing condtion,
// one node is the list, list is ordered.
if ( ptLinkFirst == ptLinkLast )
{
return ;
}
// cursor initialization
ptLinkLeft = ptLinkFirst;
ptLinkRight = ptLinkLast;
// select first node as the pivot ( center pointer )
ptLinkPivot = ptLinkLeft;
ptNodePivot = list_entry(ptLinkPivot, T_NODE, tLinkNode);
szPivot = ptNodePivot->str;
while( ptLinkLeft!= ptLinkRight )
{
// search first node less than pivot from right end
while( ptLinkLeft!= ptLinkRight )
{
ptNodeRight = list_entry(ptLinkRight, T_NODE, tLinkNode);
// find it
if ( strcmp(ptNodeRight->str, szPivot) < 0 )
{
// save the string to pivot pointer node
// note, this time pivot pointer is ptLinkLeft
ptNodeLeft = list_entry(ptLinkLeft, T_NODE, tLinkNode);
ptNodeLeft->str = ptNodeRight->str;
// now pivot node is less than szPivot, so ptLinkLeft node is not pivot any more, should set ptLinkLeft to its next node
ptLinkLeft = ptLinkLeft->next;
// right searching over
break;
}
// not found yet
else
{
//set right node to its previous node, for next comparing
ptLinkRight = ptLinkRight->prev;
}
}
// search first node greater than pivot from left end
while( ptLinkLeft!= ptLinkRight )
{
ptNodeLeft = list_entry(ptLinkLeft, T_NODE, tLinkNode);
// find it
if ( strcmp(ptNodeLeft->str, szPivot) > 0 )
{
// save the string to pivot pointer node,
// note after first while, ptNodePivot is ptLinkRight
ptNodeRight= list_entry(ptLinkRight, T_NODE, tLinkNode);
ptNodeRight->str = ptNodeLeft->str;
// now pivot node is greater than szPivot, so ptLinkRight node is not pivot any more, should set ptLinkRight to its previous node
ptLinkRight = ptLinkRight->prev;
// left searching over
break;
}
// not found yet
else
{
//set right node to its next node, for next comparing
ptLinkLeft = ptLinkLeft->next;
}
}
}
//now center pointer node(pivot) is ptLinkLeft, which is equal to ptLinkRight
//save pivot node string
ptLinkPivot = ptLinkLeft;
ptNodePivot = list_entry(ptLinkPivot, T_NODE, tLinkNode);
ptNodePivot->str = szPivot;
//now recursively, quick sort pivot left list
if ( ptLinkPivot != ptLinkFirst )
{
_List_QuickSort( ptLinkFirst, ptLinkPivot->prev );
}
//now recursively, quick sort pivot right list
if ( ptLinkPivot != ptLinkLast )
{
_List_QuickSort( ptLinkPivot->next, ptLinkLast );
}
}
void QuickSortList(PT_LIST_LINKNODE ptListHead)
{
PT_LIST_LINKNODE ptLinkFirst = NULL;
PT_LIST_LINKNODE ptLinkLast = NULL;
if ( IsListEmpty(ptListHead) )
{
return ;
}
ptLinkFirst = ptListHead->next;
ptLinkLast = ptListHead->prev;
_List_QuickSort(ptLinkFirst, ptLinkLast);
}
一处宏函数定义与指针关系的经验总结
调试过程发现 递归出现死循环， 最终查证为定义的链表宏（list_add_head 在表头插入元素）有问题：
定义的 在链表任意两个相邻位置的节点 间插入 一个新节点 宏如下：
if 分支处理 链表为空的情况， prev next 都为链表头
else 分支处理， 链表不为空的情况。
// insert new link node between previous link node and next link node
// note: if clause is must item to add node to empty list, otherwise list_add_tail error
#define _list_add(newLink, prevLink, nextLink) do{\
(newLink)->next = (nextLink); (newLink)->prev = (prevLink); if ( (prevLink) == (nextLink) ){ (prevLink)->next = (newLink); (prevLink)->prev = (newLink); }else{ (prevLink)->next = (newLink); (nextLink)->prev = (newLink); } } while(0)
有问题的 list_add_head 宏如下：
// add new list node to list head
#define list_add_head(ptListHead, ptListNewLink) do {\
_list_add((ptListNewLink), (ptListHead), (ptListHead)->next); } while(0)
链表为空没有问题， 当链表不为空， 则这种写法， 被 _list_add替换后， 其中else分支别替换为
则可以看出 (ptListHead)->next 本来是指代 表头的下一个节点， 但是被替换后由于其上的依据， 导致了 (ptListHead)->next 值被修改为 新插入的 节点，
则产生语义错误！！
}else{ (ptListHead)->next = (newLink); ((ptListHead)->next)->prev = (newLink); }\
修正方法， 在宏行数的入参中 不要放置 指针表达式， 取而代之的为指针变量， 即让入参指针直接指代目标节点， 避免依赖其他节点的指针值：
这样被替换后， 就没有你问题了， 因为入参就是直接代表 对应的节点。
// add new list node to list head
#define list_add_head(ptListHead, ptListNewLink) do {\
PT_LIST_LINKNODE ptPrevLink = (ptListHead); PT_LIST_LINKNODE ptNextLink = (ptListHead)->next; _list_add((ptListNewLink), (ptPrevLink), (ptNextLink)); } while(0)
查看linux内核实现的链表添加为函数形式， 其采用内联函数， 可以避免宏函数的参数（指针表达式）被替换后语义混乱的情况， 即避免宏的副作用：
http://blog.csdn.net/sunweizhong1024/article/details/7586383
/**
* list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static __inline__ void list_add_tail(struct list_head *_new, struct list_head *head)
{
__list_add(_new, head->prev, head);
}
/*
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static __inline__ void __list_add(struct list_head * _new,
struct list_head * prev,
struct list_head * next)
{
next->prev = _new;
_new->next = next;
_new->prev = prev;
prev->next = _new;
}