fd

Author: dingjikerbo

solution/src/main/java/com/inuker/solution/FindModeInBinarySearchTree.java

@@ -13,9 +13,19 @@
 /**
  * 这题是要找BST中出现次数最多的节点集合，这里允许有重复节点
  * 思路很简单，中序遍历，会按升序排列，再统计重复的值
+ * 但是这样会消耗额外空间，对于类似于1，2，3，4...n-1, n-1，这种，所有的元素都只出现1次，
+ * 唯独n-1出现了两次，这样mList中要保存整棵树的元素，所以空间是O(n），而返回值事实上只有一个
+ * 这是分配在堆上的而非栈上，不能忽略。
+ *
+ * 如果额外空间要求为O(l)，则分开两次扫描，第一次扫描最大次数，不记录最大次数的元素集合
+ * 第二次根据最大次数来收集元素
  */
 public class FindModeInBinarySearchTree {
 
+    /**
+     * 这题类似于在一个有序的序列中查找频率最高的元素集合
+     */
+
     private List<Integer> mList;
 
     private int mCurCount;
@@ -61,4 +71,51 @@ private void inorderTraverse(TreeNode root) {
 
         inorderTraverse(root.right);
     }
+
+
+    /**
+     * 如下是空间为O(l)的写法
+     */
+    int mCurVal;
+    int mMaxElemSize;
+    int idx;
+    int[] modes;
+
+    public int[] findMode2(TreeNode root) {
+        helper(root);
+        modes = new int[mMaxElemSize];
+        mCurCount = 0;
+        helper(root);
+        return modes;
+    }
+
+    private void helper(TreeNode node) {
+        if (node == null) {
+            return;
+        }
+
+        helper(node.left);
+
+        if (node.val == mCurVal) {
+            mCurCount++;
+        } else {
+            mCurCount = 1;
+            mCurVal = node.val;
+        }
+
+        if (modes == null) {
+            if (mCurCount == mMaxCount) {
+                mMaxElemSize++;
+            } else if (mCurCount > mMaxCount) {
+                mMaxElemSize = 1;
+                mMaxCount = mCurCount;
+            }
+        } else {
+            if (mCurCount == mMaxCount) {
+                modes[idx++] = mCurVal;
+            }
+        }
+
+        helper(node.right);
+    }
 }

test/src/main/java/com/inuker/test/main.java

@@ -5,6 +5,7 @@
 import com.inuker.solution.InorderSuccessorInBST;
 import com.leetcode.library.TreeNode;
 
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Stack;
@@ -22,56 +23,62 @@ public static void main(String[] args) {
         }
     }
 
-    public static List<Integer> closestKValues(TreeNode root, double target, int k) {
-        Stack<TreeNode> preStack = new Stack<>();
-        Stack<TreeNode> postStack = new Stack<>();
-
-        for (TreeNode node = root; node != null; ) {
-            if (target <= node.val) {
-                postStack.push(node);
-                node = node.left;
-            } else {
-                preStack.push(node);
-                node = node.right;
-            }
-        }
+    int mMaxCount;
+    int mCurVal;
+    int mCurCount;
+    int mMaxElemSize;
 
-        List<Integer> list = new LinkedList<>();
-
-        for (int i = 0; i < k; i++) {
-            if (preStack.isEmpty()) {
-                list.add(getNextSuccessor(postStack).val);
-            } else if (postStack.isEmpty()) {
-                list.add(getNextPredesessor(preStack).val);
-            } else if (Math.abs(target - preStack.peek().val) < Math.abs(target - postStack.peek().val)) {
-                list.add(getNextPredesessor(preStack).val);
-            } else {
-                list.add(getNextSuccessor(postStack).val);
-            }
-        }
+    int idx;
 
-        return list;
+    public int[] findMode(TreeNode root) {
+        helper(root);
+        int[] result = new int[mMaxElemSize];
+        mCurCount = 0;
+        unite(root, result);
+        return result;
     }
 
-    private static TreeNode getNextPredesessor(Stack<TreeNode> stack) {
-        if (stack.isEmpty()) {
-            return null;
+    private void unite(TreeNode node, int[] result) {
+        if (node == null) {
+            return;
+        }
+        unite(node.left, result);
+
+        if (node.val == mCurVal) {
+            mCurCount++;
+        } else {
+            mCurCount = 1;
+            mCurVal = node.val;
         }
-        TreeNode ret = stack.pop();
-        for (TreeNode node = ret.left; node != null; node = node.right) {
-            stack.push(node);
+
+        if (mCurCount == mMaxCount) {
+            result[idx++] = mCurVal;
         }
-        return ret;
+
+        unite(node.right, result);
     }
 
-    private static TreeNode getNextSuccessor(Stack<TreeNode> stack) {
-        if (stack.isEmpty()) {
-            return null;
+    private void helper(TreeNode node) {
+        if (node == null) {
+            return;
         }
-        TreeNode ret = stack.pop();
-        for (TreeNode node = ret.right; node != null; node = node.left) {
-            stack.push(node);
+
+        helper(node.left);
+
+        if (node.val == mCurVal) {
+            mCurCount++;
+        } else {
+            mCurCount = 1;
+            mCurVal = node.val;
         }
-        return ret;
+
+        if (mCurCount == mMaxCount) {
+            mMaxElemSize++;
+        } else if (mCurCount > mMaxCount) {
+            mMaxElemSize = 1;
+            mMaxCount = mCurCount;
+        }
+
+        helper(node.right);
     }
 }