[LeetCode]89. Partition List链表划分

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,
Given 1->4->3->2->5->2 and x = 3,
return 1->2->2->4->3->5.

Subscribe to see which companies asked this question

 

解法1：从头往后，找出第一个值大于等于x的节点，然后在这个节点后面找出第一个值小于x的节点，最后将这个小的节点插在大的节点的前面；然后指针移动到上一步的第一个大节点处，继续循环进行上一步处理，直至后面没有值小于x的节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == NULL || head->next == NULL) return head;
        ListNode *help = new ListNode(0);
        help->next = head;
        ListNode* prev = help, *curr = prev->next;
        while (curr != NULL) {
            while (curr != NULL && curr->val < x)  { // 找出第一个大于等于x的节点
                curr = curr->next;
                prev = prev->next;
            }
            if (curr == NULL) break;
            ListNode *next = curr->next, *temp = curr; // 注意不是从第一个节点开始
            while (next != NULL && next->val >= x) { // 找出第一个小于x的节点
                next = next->next;
                temp = temp->next;
            }
            if (next == NULL) break;
            ListNode* tmp = next->next;
            next->next = prev->next; // 将小于x的节点插在大于等于x的节点之前
            prev->next = next;
            temp->next = tmp;
            prev = next; // 前移到下一个节点
            curr = prev->next;
        }
        return help->next;
    }
};

实际上外层while循环里的第一个while循环可以拿到外层while循环外面，因为后面每次找到的第一个值大于等于x的节点就是curr本身了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if (head == NULL || head->next == NULL) return head;
        ListNode *help = new ListNode(0);
        help->next = head;
        ListNode* prev = help;
        while (prev->next != NULL && prev->next->val < x) prev = prev->next;
        ListNode* curr = prev;
        while (curr->next != NULL) {
            if (curr->next != NULL && curr->next->val >= x)
                curr = curr->next;
            else {
                ListNode* tmp = curr->next;
                curr->next = tmp->next;
                tmp->next = prev->next;
                prev->next = tmp;
                prev = prev->next;
            }
        }
        return help->next;
    }
};

解法2：另一种方法就是遍历一遍链表，分别将值小于x和值大于等于x的节点分为两个链表链接起来，然后再将后者链接在前者的末尾就可以了。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* head1 = new ListNode(0);
        ListNode* head2 = new ListNode(0);
        ListNode *next1 = head1, *next2 = head2, *curr = head;
        while (curr != NULL) {
            if (curr->val < x) {
                next1->next = curr;
                next1 = next1->next;
                curr = curr->next;
                next1->next = NULL;
            }
            else {
                next2->next = curr;
                next2 = next2->next;
                curr = curr->next;
                next2->next = NULL;
            }
        }
        next1->next = head2->next;
        return head1->next;
    }
};