0086. Partition List

coderbean · coderbean · commit 1ed848fa05f3 · 2019-08-01T13:22:11.000+08:00
diff --git a/src/main/java/leetcode/0086. Partition List.md b/src/main/java/leetcode/0086. Partition List.md
@@ -0,0 +1,60 @@
+### [86\. Partition List](https://leetcode.com/problems/partition-list/)
+
+Difficulty: **Medium**
+
+
+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.
+
+**Example:**
+
+```
+Input: head = 1->4->3->2->5->2, x = 3
+Output: 1->2->2->4->3->5
+```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode partition(ListNode head, int x) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode fakeHeader = new ListNode(0);
+        fakeHeader.next = head;
+        ListNode curr = fakeHeader;
+        ListNode cutPoint = null;
+        while (curr.next != null) {
+            if (curr.next.val >= x) {
+                if (cutPoint == null) {
+                    cutPoint = curr;
+                }
+                curr = curr.next;
+            } else if (cutPoint != null) {
+                ListNode node = curr.next;
+                curr.next = node.next;
+                node.next = cutPoint.next;
+                cutPoint.next = node;
+                cutPoint = node;
+            } else {
+                curr = curr.next;
+            }
+        }
+        return fakeHeader.next;
+    }
+}
+```
+![pic](https://raw.githubusercontent.com/PicGoBed/PicBed/master/2019-08-01-ACf21S.jpg)
diff --git a/src/main/java/leetcode/_86_/Main.java b/src/main/java/leetcode/_86_/Main.java
@@ -0,0 +1,30 @@
+package leetcode._86_;
+
+import leetcode.common.ListNode;
+
+/**
+ * Created by zhangbo54 on 2019-03-04.
+ */
+public class Main {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        ListNode node1 = new ListNode(1);
+        ListNode node2 = new ListNode(4);
+        ListNode node31 = new ListNode(3);
+        ListNode node32 = new ListNode(2);
+        ListNode node41 = new ListNode(5);
+        ListNode node42 = new ListNode(2);
+        ListNode node5 = new ListNode(2);
+        node1.next = node2;
+        node2.next = node31;
+        node31.next = node32;
+        node32.next = node41;
+        node41.next = node42;
+        node42.next = node5;
+
+
+        System.out.println(solution.partition(node1, 3));
+    }
+}
+
diff --git a/src/main/java/leetcode/_86_/Solution.java b/src/main/java/leetcode/_86_/Solution.java
@@ -0,0 +1,40 @@
+package leetcode._86_;
+
+import leetcode.common.ListNode;
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode partition(ListNode head, int x) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode fakeHeader = new ListNode(0);
+        fakeHeader.next = head;
+        ListNode curr = fakeHeader;
+        ListNode cutPoint = null;
+        while (curr.next != null) {
+            if (curr.next.val >= x) {
+                if (cutPoint == null) {
+                    cutPoint = curr;
+                }
+                curr = curr.next;
+            } else if (cutPoint != null) {
+                ListNode node = curr.next;
+                curr.next = node.next;
+                node.next = cutPoint.next;
+                cutPoint.next = node;
+                cutPoint = node;
+            } else {
+                curr = curr.next;
+            }
+        }
+        return fakeHeader.next;
+    }
+}
diff --git a/src/main/java/leetcode/_86_/solution.md b/src/main/java/leetcode/_86_/solution.md
@@ -0,0 +1,60 @@
+### [86\. Partition List](https://leetcode.com/problems/partition-list/)
+
+Difficulty: **Medium**
+
+
+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.
+
+**Example:**
+
+```
+Input: head = 1->4->3->2->5->2, x = 3
+Output: 1->2->2->4->3->5
+```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode partition(ListNode head, int x) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode fakeHeader = new ListNode(0);
+        fakeHeader.next = head;
+        ListNode curr = fakeHeader;
+        ListNode cutPoint = null;
+        while (curr.next != null) {
+            if (curr.next.val >= x) {
+                if (cutPoint == null) {
+                    cutPoint = curr;
+                }
+                curr = curr.next;
+            } else if (cutPoint != null) {
+                ListNode node = curr.next;
+                curr.next = node.next;
+                node.next = cutPoint.next;
+                cutPoint.next = node;
+                cutPoint = node;
+            } else {
+                curr = curr.next;
+            }
+        }
+        return fakeHeader.next;
+    }
+}
+```
+![pic](https://raw.githubusercontent.com/PicGoBed/PicBed/master/2019-08-01-ACf21S.jpg)
