将单向链表按某值划分成左边小、中间相等、右边大的形式

【说明】：

　　本文是左程云老师所著的《程序员面试代码指南》第二章中“将单向链表按某值划分成左边小、中间相等、右边大的形式”这一题目的C++复现。

　　本文只包含问题描述、C++代码的实现以及简单的思路，不包含解析说明，具体的问题解析请参考原书。

　　感谢左程云老师的支持。

【题目】：

　　给定一个单向链表的头节点 head，节点的值类型为整形，再给定一个整数 pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot 的节点，中间部分都是值等于 pivot 的节点，右部分都是值大于 pivot 的节点。除这个要求外，对调整后的节点顺序没有更多的要求。

　　例如：链表 9->0->4->5->1，pivot=3

　　调整后链表可以是 1->0->4->9->5，也可以是 0->1->9->5->4。总之，满足左部分都是小于 3 的节点，中间部分都是等于 3 的节点（本例中这个部分为空），右部分都是大于 3 的节点即可。对某部分内部的节点顺序不做要求。

【进阶】：

　　在原问题的要求之上再增加如下两个要求：

• 　　在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左到右的顺序与原链表中节点的先后次序一致。

　　例如：链表9->0->4->5->1，pivot=3。调整后的链表是 0->1->9->4->5。在满足原问题的同时，左部分节点从左到右为 0、1。在原链表中也是先出现 0，后出现 1，中间部分在本例中为空，不再讨论；右部分节点从左到右为9、4、5。在原链表中也是先出现9，然后出现4，最后出现5。

• 　　如果链表长度为N，时间复杂度请达到 O(N)，额外的空间复杂度请达到 O(1)。

 【思路】：

　　普通解法：使用快速排序中的分区方法即可。

　　进阶解法：在原链表中按顺序提出左、中、右三个子链表，再进行组合

【编译环境】：

　　CentOS6.7（x86_64）

　　gcc 4.4.7

 【实现】：

　　实现及测试代码：

/*
 *文件名：lists_partition.cpp
 *作者：
 *摘要：用C++实现将单向链表按某值划分成左边小、中间相等、右边大的形式
 */

#include <iostream>

using namespace std;

struct Node
{
    int value;
    Node *next;
};

//打印链表
void printLists(Node *head)
{
    while(NULL != head)
    {
        cout << head->value << " " ;
        head = head->next;
    }
    cout << endl;
}

//交换链表中的数据
void swap(Node *a,Node *b)
{
    int tmp = a->value;
    a->value = b->value;
    b->value = tmp;
}


//快速排序中的分区方法
void arrPartition(Node *arr,int len,int pivot)
{
    int index = 0;
    len--;
    while(index < len)
    {
        while(index < len && arr[index].value <= pivot)
            index++;
        swap(&arr[index],&arr[len]);
        while(index < len && arr[len].value >= pivot)
            len--;
        swap(&arr[index],&arr[len]);    
    }
}

//非进阶算法
Node* listPartition1(Node *head,int pivot)
{
    if(NULL == head)
        return NULL;
    Node *cur = head;
    int len = 0;
    while(NULL != cur)    //统计链表长度
    {
        len++;
        cur = cur->next;
    }
    
    Node *arr = new Node[len];
    cur = head;
    for(int i=0;i<len;i++)
    {
        arr[i] = *cur;
        cur = cur->next;
    }
    arrPartition(arr,len,pivot); //分区
    for(int i=1;i<len;i++)
    {
        arr[i-1].next = &arr[i];
        Node *ptr = head;
        head = head->next;
        delete ptr;
    }
    arr[len-1].next = NULL;
    delete head;
    return arr;
}

//进阶算法
Node *listPartition2(Node *head,int pivot)
{
    Node *sH = NULL;    //小头
    Node *sT = NULL;    //小尾
    Node *eH = NULL;    //相等头
    Node *eT = NULL;    //相等尾
    Node *bH = NULL;    //大头
    Node *bT = NULL;    //大尾

    while(NULL != head)
    {
        Node *next = head->next;
        head->next = NULL;

        if(head->value < pivot)
        {
            if(NULL == sH)
            {
                sH = head;
                sT = head;
            }
            else
            {
                sT->next = head;
                sT = head;
            }
        }
        else if(head->value == pivot)
        {
            if(NULL == eH)
            {
                eH = head;
                eT = head;
            }
            else
            {
                eT->next = head;
                eT = head;
            }    
        }
        else
        {
            if(NULL == bH)
            {
                bH = head;
                bT = head;
            }
            else
            {
                bT->next = head;
                bT = head;
            }
        }
        head = next;
    }    
    if(NULL != sT)    //小段链接相等段
    {
        sT->next = eH;
        eT = (NULL == eT ? sT : eT);
    }

    if(NULL != eT)    //中段链接大段
        eT->next = bH;
    return NULL != sH ? sH : NULL != eH ? eH : bH;
}


int main()
{
    int arr[] = {9,0,4,5,1};
    Node *head1 = NULL;
    Node *ptr1 = NULL;
    Node *head2 = NULL;
    Node *ptr2 = NULL;
    for(int i=0;i<5;i++)
    {
        if(NULL == head1 && NULL ==head2)
        {
            head1 = new Node;
            head1->value = arr[i];
            head1->next = NULL;
            ptr1 = head1;
            
            head2 = new Node;
            head2->value = arr[i];
            head2->next = NULL;
            ptr2 = head2;
            continue;
        }
        ptr1->next = new Node;
        ptr1 = ptr1->next;
        ptr1->value = arr[i];
        ptr1->next = NULL;
        
        ptr2->next = new Node;
        ptr2 = ptr2->next;
        ptr2->value = arr[i];
        ptr2->next = NULL;
    }
    cout << "list before partiton: " << endl;
    printLists(head1);
    cout << "not ordered partition: " << endl;
    ptr1 = listPartition1(head1,3);
    printLists(ptr1);
    
    cout << "list before partiton: " << endl;
    printLists(head2);
    cout << "ordered partition: " << endl;
    ptr2 = listPartition2(head2,3);
    printLists(ptr2);
    return 0;
}

【说明】：

• 　　关于利用快速排序中的分区方法时，我并未按照左老师所写的代码重写一遍，但是原理是一致的，有兴趣的同学可以参考原书。
• 　　测试代码较为繁琐，大家凑合着看，因为我用C++重写此题时，使用了delete，所以为了测试两个算法，做了两个相同的链表。

注：

　　转载请注明出处；

　　转载请注明源思路来自于左程云老师的《程序员代码面试指南》。