86. 分隔链表

迭代

class Solution {
    public ListNode partition(ListNode head, int x) {

        if (head == null){
            return head;
        }

        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;

        /**
         * 找到最后一个节点last，将每个值大于等于x的节点都放在last后面，小于x的节点不动
         */
        ListNode last = head;
        int size = 1;

        while (last.next != null){

            last = last.next;
            size++;
        }

        /**
         * 后面会不断有新的节点变成last，因此要记录下链表的长度，这是循环结束的条件
         */
        ListNode prev = dummyHead;
        ListNode cur = head;

        while (size > 0){

            if (cur.val < x){

                prev = cur;
                cur = cur.next;
            }
            else {

                /**
                 * cur.next == null，说明这个节点不仅是最后一个节点，也是最大的节点，其后面根本没有节点，就不用继续循环了
                 */
                if (cur.next == null){
                    break;
                }

                prev.next = cur.next;
                last.next = cur;
                cur.next = null;
                last = cur;
                cur = prev.next;
            }

            size--;
        }

        return dummyHead.next;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */

两个链表

class Solution {
    public ListNode partition(ListNode head, int x) {

        /**
         * 创建两个链表的头节点，分别存放小于x和大于等于x的节点，最后合并
         * 虚拟头节点不动
         */
        ListNode small = new ListNode(-1);
        ListNode dummyHeadS = small;
        ListNode large = new ListNode(-1);
        ListNode dummyHeadL = large;

        while (head != null){

            if (head.val < x){

                small.next = head;
                small = small.next;
            }
            else {

                large.next = head;
                large = large.next;
            }

            head = head.next;
        }

        /**
         * 合并时，大链表的尾指针指向null，小链表的尾指针指向大链表的头节点
         */
        large.next = null;
        small.next = dummyHeadL.next;

        return dummyHeadS.next;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */

https://leetcode-cn.com/problems/partition-list/