Merge pull request doocs#222 from huaxu1024/master

Create Solution.java

Author: yanglbme

solution/0148.Sort List/README_EN.md

@@ -0,0 +1,16 @@
+# Sort List
+
+Sort a linked list in O(n log n) time using constant space complexity.
+
+
+## Example 1:
+```
+ Input: 4->2->1->3
+ Output: 1->2->3->4
+```
+
+## Example 2:
+```
+ Input: -1->5->3->4->0
+ Output: -1->5->3->4->0
+```

solution/0148.Sort List/Solution2.java

@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode sortList(ListNode head) {
+        if (head == null || head.next == null)
+            return head;
+        // get middle index node
+        ListNode fast = head.next, slow = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        // cut
+        ListNode tmp = slow.next;
+        slow.next = null;
+        ListNode left = sortList(head);
+        ListNode right = sortList(tmp);
+        ListNode h = new ListNode(0);
+        ListNode res = h;
+        // merge
+        while (left != null && right != null) {
+            if (left.val < right.val) {
+                h.next = left;
+                left = left.next;
+            } else {
+                h.next = right;
+                right = right.next;
+            }
+            h = h.next;
+        }
+        h.next = left != null ? left : right;
+        return res.next;
+    }
+}

solution/0148.Sort List/Solution3.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ *
+ * O(nlogn) ==》 time complexity
+ * O(n)     ==》space complexity
+ */
+class Solution {
+
+    public ListNode sortList(ListNode head) {
+        List<Integer> numList = new ArrayList<>();
+        while (head != null) {
+            numList.add(head.val);
+            head = head.next;
+        }
+        Collections.sort(numList);
+
+        head = new ListNode(0);
+        ListNode res = head;
+        for (Integer num : numList) {
+            head.next = new ListNode(num);
+            head = head.next;
+        }
+        return res.next;
+    }
+}

solution/1114.Print in Order/README_EN.md

@@ -0,0 +1,31 @@
+# Print in Order
+
+Suppose we have a class:
+```
+public class Foo {
+  public void first() { print("first"); }
+  public void second() { print("second"); }
+  public void third() { print("third"); }
+}
+```
+The same instance of `Foo` will be passed to three different threads. 
+
+- Thread A will call `first()`.
+- Thread B will call `second()`. 
+- Thread C will call `third()`. 
+
+Design a mechanism and modify the program to ensure that `second()` is executed after `first()`, and `third()` is executed after second().
+
+## Example 1:
+```
+ Input: [1,2,3]
+ Output: "firstsecondthird"
+ Explanation: There are three threads being fired asynchronously. The input [1,2,3] means thread A calls first(), thread B calls second(), and thread C calls third(). "firstsecondthird" is the correct output.
+```
+
+## Example 2:
+```
+ Input: [1,3,2]
+  Output: "firstsecondthird"
+  Explanation: The input [1,3,2] means thread A calls first(), thread B calls third(), and thread C calls second(). "firstsecondthird" is the correct output.
+```

solution/1114.Print in Order/Solution2.java

@@ -0,0 +1,23 @@
+import java.util.concurrent.CountDownLatch;
+
+class Foo {
+    private CountDownLatch one = new CountDownLatch(1);
+    private CountDownLatch two = new CountDownLatch(1);
+    public Foo() {}
+
+    public void first(Runnable printFirst) throws InterruptedException {
+        printFirst.run();
+        one.countDown();
+    }
+
+    public void second(Runnable printSecond) throws InterruptedException {
+        one.await();
+        printSecond.run();
+        two.countDown();
+    }
+
+    public void third(Runnable printThird) throws InterruptedException {
+        two.await();
+        printThird.run();
+    }
+}

solution/1114.Print in Order/Solution3.java

@@ -0,0 +1,22 @@
+class Foo {
+
+    private volatile int index = 1;
+    public Foo() {}
+
+    public void first(Runnable printFirst) throws InterruptedException {
+        while (index != 1) {}
+        printFirst.run();
+        index = 2;
+    }
+
+    public void second(Runnable printSecond) throws InterruptedException {
+        while (index != 2) {}
+        printSecond.run();
+        index = 3;
+    }
+
+    public void third(Runnable printThird) throws InterruptedException {
+        while (index != 3) {}
+        printThird.run();
+    }
+}

solution/1115.Print FooBar Alternately/README_EN.md

@@ -0,0 +1,33 @@
+# Print FooBar Alternately
+
+Suppose you are given the following code:
+```
+class FooBar {
+  public void foo() {
+    for (int i = 0; i < n; i++) {
+      print("foo");
+    }
+  }
+
+  public void bar() {
+    for (int i = 0; i < n; i++) {
+      print("bar");
+    }
+  }
+}
+```
+The same instance of `FooBar` will be passed to two different threads. Thread A will call `foo()` while thread B will call `bar()`. Modify the given program to output "**foobar**" n times.
+
+## Example 1:
+```
+ Input: n = 1
+ Output: "foobar"
+ Explanation: There are two threads being fired asynchronously. One of them calls foo(), while the other calls bar(). "foobar" is being output 1 time.
+```
+
+## Example 2:
+```
+ Input: n = 2
+  Output: "foobarfoobar"
+  Explanation: "foobar" is being output 2 times.
+```

solution/1115.Print FooBar Alternately/Solution.java

@@ -0,0 +1,40 @@
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+
+class FooBar {
+
+    private int n;
+    private Lock lock;
+    private volatile Boolean flag;
+
+    public FooBar(int n) {
+        this.n = n;
+        this.flag = true;
+        this.lock = new ReentrantLock(true);
+    }
+
+    public void foo(Runnable printFoo) throws InterruptedException {
+        for (int i = 0; i < n;) {
+            lock.lock();
+            if (flag) {
+                printFoo.run();
+                flag = false;
+                i++;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void bar(Runnable printBar) throws InterruptedException {
+        for (int i = 0; i < n;) {
+            lock.lock();
+            if (!flag) {
+                printBar.run();
+                flag = true;
+                i++;
+            }
+            lock.unlock();
+        }
+    }
+}

solution/1115.Print FooBar Alternately/Solution2.java

@@ -0,0 +1,31 @@
+import java.util.concurrent.Semaphore;
+
+
+class FooBar {
+
+    private int n;
+    private Semaphore semaphoreA;
+    private Semaphore semaphoreB;
+
+    public FooBar(int n) {
+        this.n = n;
+        this.semaphoreA = new Semaphore(1);
+        this.semaphoreB = new Semaphore(0);
+    }
+
+    public void foo(Runnable printFoo) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            semaphoreA.acquire();
+            printFoo.run();
+            semaphoreB.release();
+        }
+    }
+
+    public void bar(Runnable printBar) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            semaphoreB.acquire();
+            printBar.run();
+            semaphoreA.release();
+        }
+    }
+}

solution/1115.Print FooBar Alternately/Solution3.java

@@ -0,0 +1,33 @@
+import java.util.concurrent.CountDownLatch;
+
+
+class FooBar {
+
+    private int n;
+    private CountDownLatch countDownLatchA;
+    private CountDownLatch countDownLatchB;
+
+    public FooBar(int n) {
+        this.n = n;
+        this.countDownLatchA = new CountDownLatch(1);
+        this.countDownLatchB = new CountDownLatch(1);
+    }
+
+    public void foo(Runnable printFoo) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            countDownLatchA.await();
+            printFoo.run();
+            countDownLatchB.countDown();
+            countDownLatchA = new CountDownLatch(1);
+        }
+    }
+
+    public void bar(Runnable printBar) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            countDownLatchA.countDown();
+            countDownLatchB.await();
+            printBar.run();
+            countDownLatchB = new CountDownLatch(1);
+        }
+    }
+}