quick_sort algorithm

思想：快速排序是找出一个元素（理论上可以随便找一个），作为基准(pivot)，然后对数组进行分区操作,使基准左边元素的值都不大于基准值，基准右边的元素值都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。

记忆技巧：挖洞+填坑

void quick_sort(int a[],int left,int right)
{
	if(left<right)
	{
		int i=left,j=right,temp=a[i];//挖洞
		while(i<j)
		{
			while(i<j&&a[j]>=temp)
			{
				j--;
			}
			if(i<j)
			{
				a[i++]=a[j];//填坑+挖洞
			}
			while(i<j&&a[i]<temp)
			{
				i++;
			}
			if(i<j)
			{
				a[j--]=a[i];//填坑+挖洞
			}		
		}
		a[i]=temp;//填坑
		quick_sort(a,left,i-1);
		quick_sort(a,i+1,right);
	}
}

单链表的快排：

如果是单链表排序，由于只有next指针，将不能像数组从后往前遍历元素，因此上面的实现不再适用于单链表。但是核心思想不便，链表的优势是可以O(1)的向链表后边插入节点。因此partition的时候，新建两个指针，lp保存比支点小的节点，rp保存比支点大的节点。O(N)遍历链表，节点比支点小时插入lp链表，反之插入rp链表。遍历结束后，按照lp->支点->rp的顺序，将链表进行组装，即可完成partition需要的操作,时间复杂度也是O(N)。

leetcode的测试数据，有一组[2,2,3,3,1,3,2,1…]的数据，只有1-3三个整数，出现65536次。快排面对这组数据，复杂度会降为O(N^2),导致TLE。使用了剪枝技巧，当子数组中的元素全部相等，即最大值等于最小值，就不继续递归。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head==NULL) return head;
        ListNode *lRoot = new ListNode(-1);
        ListNode *rRoot = new ListNode(-1);
        ListNode *piot = head;

        ListNode *lp = lRoot,*rp = rRoot;
        ListNode *lastLeft = NULL;
        int minL=INT_MAX,minR=INT_MAX,maxL=INT_MIN,maxR=INT_MIN;
        head = head->next;
        while(head!=NULL){
            if(head->val <= piot->val){
                minL = min(minL,head->val);
                maxL = max(maxL,head->val);
                lp->next = head;
                lp = lp->next;
                head = head->next;
                lp->next = NULL;
            }
            else{
                minR = min(minR,head->val);
                maxR = max(maxR,head->val);
                rp->next = head;
                rp = rp->next;
                head = head->next;
                rp->next = NULL;
            }
        }
        if(minL==maxL)
            lp = lRoot->next;
        else
            lp = sortList(lRoot->next);

        if(minR==maxR)
            rp = rRoot->next;
        else
            rp = sortList(rRoot->next);

        lastLeft = lp;
        while(lastLeft!=NULL && lastLeft->next!=NULL) lastLeft = lastLeft->next;

        //merge
        if(lp==NULL){
            piot->next = rp;
            return piot;
        }
        else{
            lastLeft->next = piot;
            piot->next = rp;
            return lp;
        }
    }
};