Partition List

https://oj.leetcode.com/problems/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.

解题思路：

这个题目不算复杂， 但我在其中的一个子问题上卡了很长时间，只能说是代码太不熟悉。

从宏观上思考题目，遇到比x小的节点（1）可直接跳过不管。遇到>=x的节点，就把他们都[4,3]往后移动，移到下一个比x小(2)的节点，再把这个小于x的节点(2)放到之前大于x区域的第一个位置(4)。等等，这么说好像有点问题，其实是反过来了。为什么？

其实是，遇到>=x的节点不动，但是记录一个位置，就是这个连续都是>=x数字的区域的第一个位置。一旦遇到<x的节点，那么这个区域就清晰了，里面所有元素都>=x。于是，将这个区域整体后移一个，再将当前<x的这个节点放到这个区域的第一个。类似于将区域的最后一个元素放到首元素。这样，原来元素的顺序也不会打乱，是稳定的变化。

同时，把记录这个>=x区域的开始位置后移一个，因为他们都只后移了一位。

然后游标往后，继续遍历整个链表。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public ListNode partition(ListNode head, int x) {

        ListNode swapNode = head;

        ListNode traverseNode = head;

        ListNode returnNode = head;

        

        while(traverseNode != null){

            if(traverseNode.val >= x){

                //do nothing

            }

            //考虑例子1->4->3->2->5->2，traverse到2，swapNode在4

            if(traverseNode.val < x){

                //留着一个备份，因为下面swapNode要往后移动，一直到traverseNode

                ListNode tempNode = swapNode;

                

                //给traverseNode的值留一个备份，后面和swapNode后节点交换

                int temp = traverseNode.val;

                

                //从[swapNode, traverseNode)每个节点往后移一个

                //即变成1->4->4->3->5->2

                int pre = swapNode.val;

                while(swapNode != traverseNode){

                    int tempValue = swapNode.next.val;

                    swapNode.next.val = pre;

                    pre = tempValue;

                    swapNode = swapNode.next;

                }

                //将前面存的最后一个值，2，赋予第一个节点4

                //即变成1->2->4->3->5->2

                tempNode.val = temp;

                //swapNode从原先的位置往后移动一个

                swapNode = tempNode.next;

            }

            // if(swapNode != null && swapNode.val < x){

            //     swapNode = swapNode.next;

            // }

            traverseNode = traverseNode.next;

        }

        return returnNode;

    }

}

这个逻辑应该来讲还是比较清晰的，但是在整个区域后移一位的时候，由于循环内需要两个临时变量，和单纯的变量交换还是有很大不同，在这个子问题上，我考虑了很久，基本功弱的缺点毕现。

再想想，一个区域内，所有元素按顺序都后移一位，难道不是用链表操作更简便吗？于是开始写代码。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public ListNode partition(ListNode head, int x) {

        ListNode traverseNode = head;

        ListNode returnNode = head;

        ListNode preTraverseNode = new ListNode(0);

        preTraverseNode.next = head;

        ListNode swapNode = preTraverseNode;

        

        while(traverseNode != null && preTraverseNode != null){

            if(traverseNode.val >= x){

                //do nothing

            }

            

            // 必须判断traverseNode != swapNode，否则引起环，死循环

            if(traverseNode.val < x && traverseNode != swapNode){

                // ListNode next = traverseNode.next;

                //返回的node不再是原head，而是被甩到前面去较小的那个

                if(swapNode.next == returnNode){

                    returnNode = traverseNode;

                }

                preTraverseNode.next = traverseNode.next;

                traverseNode.next = swapNode.next;  

                swapNode.next = traverseNode;  

                // traverseNode = next;

                traverseNode = preTraverseNode.next;

                swapNode = swapNode.next;

                continue;

                //traverseNode与pre已经到位，无需再往后移动

            }

            if(traverseNode != null && preTraverseNode != null){

                preTraverseNode = preTraverseNode.next;

                traverseNode = traverseNode.next;

            }

        }

        return returnNode;

    }

}

在实际操作中发现，需要同时取得swapNode和traverseNode的前驱节点。链表操作有个特点，快了，你就再也回不去了，因为它是单向的，如果慢了，你可以一直node.next.next...往下取值。

这里我将swapNode的初始值设置在了一个dummy的节点上，用它指向head，所有swapNode就始终比上题都往前一位，即便这样，还是很容易出错，上面正确的代码我又花了半天时间才写出，错了大概十几个版本吧。

事实上，traverseNode也可以放在这个dummy上，这样就不需要那个preTraverseNode了，原来的preTraverseNode就是现在的traverseNode，原来的traverseNode就是现在的traverseNode.next。中间只需要一个获取preTraverseNode的下一个节点保存preTranverseNode的下一个节点即可，代码如下。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) {

 *         val = x;

 *         next = null;

 *     }

 * }

 */

public class Solution {

    public ListNode partition(ListNode head, int x) {

        // ListNode traverseNode = head;

        ListNode returnNode = head;

        ListNode preTraverseNode = new ListNode(0);

        preTraverseNode.next = head;

        ListNode swapNode = preTraverseNode;

        

        while(preTraverseNode.next != null){

            if(preTraverseNode.next.val >= x){

                //do nothing

            }

            

            // 必须判断preTraverseNode.next != swapNode，否则引起环，死循环

            if(preTraverseNode.next.val < x && preTraverseNode.next != swapNode){

                //返回的node不再是原head，而是被甩到前面去较小的那个

                if(swapNode.next == returnNode){

                    returnNode = preTraverseNode.next;

                }

                //获取preTraverseNode的下一个节点，不因为下面就要改变

                ListNode nextNode = preTraverseNode.next;

                preTraverseNode.next = preTraverseNode.next.next;

                nextNode.next = swapNode.next;  

                swapNode.next = nextNode;  

                swapNode = swapNode.next;

                continue;

                //preTraverseNode.next已经到位，无需再往后移动

            }

            if(preTraverseNode.next != null){

                preTraverseNode = preTraverseNode.next;

                // preTraverseNode.next = preTraverseNode.next.next;

            }

        }

        return returnNode;

    }

}

 以上均为in place的解法，还有一种解法，遍历一次链表，将<x和>=x的值分别加入一个队列，再重新建立一个新的链表，也可以，不过不是in place。

update 2015/05/19:

二刷

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) { val = x; }

 * }

 */

public class Solution {

    public ListNode partition(ListNode head, int x) {

        if(head == null || head.next == null) {

            return head;

        }

        ListNode dummy = new ListNode(0);

        dummy.next = head;

        ListNode cur = dummy;

        ListNode slow = dummy;

        while(cur.next != null) {

            if(cur.next.val < x) {

                ListNode next = cur.next;

                cur.next = cur.next.next;

                ListNode next1 = slow.next;

                slow.next = next;

                next.next = next1;

                slow = slow.next;

                cur = next;

            } else {

                cur = cur.next;

            }

        }

        return dummy.next;

    }

}