Partition List

最新推荐文章于 2021-04-06 09:37:45 发布

原创最新推荐文章于 2021-04-06 09:37:45 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

链表（linkedlist）专栏收录该内容

20 篇文章

订阅专栏

本文介绍了一种链表分隔算法，该算法将链表中小于给定值x的节点放置在大于等于x的节点之前，并保持各部分内部节点的原始相对顺序。通过创建两个子链表分别收集小于x和大于等于x的节点，最后将两部分链接起来。

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.

Analysis:

We separate the list into two lists, one contains nodes which are smaller than x, and the other list has the rest nodes. Finally, we concatenate them.

/**
 * 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) {
        if (head == null || head.next == null) return head;
        ListNode h1 = null;
        ListNode c1 = null;
        
        ListNode h2 = null;
        ListNode c2 = null;
        
        ListNode current = head;
        ListNode next = null;
        while (current != null) {
            next = current.next;
            if (current.val < x) {
                if (h1 == null) {
                    h1 = current;
                    c1 = current;
                } else {
                    c1.next = current;
                    c1 = c1.next;
                }
                c1.next = null;
            } else {
                if (h2 == null) {
                    h2 = current;
                    c2 = current;
                } else {
                    c2.next = current;
                    c2 = c2.next;
                }
                c2.next = null;
            }
           current = next; 
        }
        if (h1 == null) return h2;
        c1.next = h2;
        return h1;
    }
}