Leetcode

Author: mengli

FindMedianFromDataStream.java

@@ -0,0 +1,60 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Median is the middle value in an ordered integer list. If the size of the list is even,
+ * there is no middle value. So the median is the mean of the two middle value.
+ * <p>
+ * For example,
+ * [2,3,4], the median is 3
+ * <p>
+ * [2,3], the median is (2 + 3) / 2 = 2.5
+ * <p>
+ * Design a data structure that supports the following two operations:
+ * <p>
+ * void addNum(int num) - Add a integer number from the data stream to the data structure.
+ * double findMedian() - Return the median of all elements so far.
+ */
+
+class MedianFinder {
+
+  private final List<Integer> elements = new ArrayList<>();
+
+  /**
+   * initialize your data structure here.
+   */
+  public MedianFinder() {
+  }
+
+  public void addNum(int num) {
+    qinsert(0, elements.size() - 1, num);
+  }
+
+  public double findMedian() {
+    if (elements.size() % 2 == 0) {
+      int q = elements.size() / 2;
+      int p = q > 0 ? q - 1 : q;
+      return (elements.get(p) + elements.get(q)) / 2.f;
+    } else {
+      return elements.get((elements.size() - 1) / 2);
+    }
+  }
+
+  private void qinsert(int start, int end, int num) {
+    if (start > end) {
+      elements.add(start, num);
+      return;
+    }
+    int index = (start + end) / 2;
+    int mid = elements.get(index);
+    if (mid == num) {
+      elements.add(index, num);
+      return;
+    }
+    if (mid < num) {
+      qinsert(index + 1, end, num);
+    } else {
+      qinsert(start, index - 1, num);
+    }
+  }
+}

ReverseNodesinkGroup.java

@@ -18,33 +18,37 @@
  */
 public class ReverseNodesinkGroup {
   public ListNode reverseKGroup(ListNode head, int k) {
-    if (head == null) return null;
-    int t = 0;
-    ListNode nextHead = head;
-    while (nextHead != null && t < k - 1) {
-      nextHead = nextHead.next;
-      t++;
-    }
-    if (nextHead == null || t < k - 1) {
+    if (head == null || k < 2) {
       return head;
-    } else {
-      ListNode nextPart = reverseKGroup(nextHead.next, k);
-      return reverseList(head, k, nextPart);
     }
+    int count = 0;
+    ListNode root = new ListNode(0);
+    root.next = head;
+    ListNode start = head;
+    ListNode end = start;
+    while (count < k - 1 && end != null && end.next != null) {
+      count++;
+      end = end.next;
+    }
+    if (count == k - 1) {
+      ListNode nextStart = end.next;
+      end.next = null;
+      reverseList(start);
+      root.next = end;
+      start.next = reverseKGroup(nextStart, k);
+    }
+    return root.next;
   }
 
-  private ListNode reverseList(ListNode head, int k, ListNode nextPart) {
-    ListNode cur = head, prev = null, next = null;
-    for (int i = 0; i < k; i++) {
+  private void reverseList(ListNode start) {
+    ListNode next;
+    ListNode cur = start;
+    ListNode prev = null;
+    while (cur != null) {
       next = cur.next;
-      if (i != 0) {
-        cur.next = prev;
-      } else {
-        cur.next = nextPart;
-      }
+      cur.next = prev;
       prev = cur;
       cur = next;
     }
-    return prev;
   }
 }