树的算法，非递归的遍历，二叉搜索树相关算法

Author: h2pl

src/数据结构/树/BST/BST中和为给定值的两个节点.java

@@ -0,0 +1,33 @@
+package 数据结构.树.BST;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class BST中和为给定值的两个节点 {
+    public boolean findTarget(TreeNode root, int k) {
+        if (root == null)return false;
+        List<Integer> list = inorder(root, new ArrayList<>());
+        int left = 0;
+        int right = list.size() - 1;
+        while (left < right) {
+            if (list.get(left) + list.get(right) > k) {
+                right --;
+            }else if(list.get(left) + list.get(right) < k) {
+                left ++;
+            }else return true;
+        }
+        return false;
+    }
+    public List<Integer> inorder(TreeNode root, List<Integer> list) {
+        if (root == null) return list;
+        inorder(root.left, list);
+        list.add(root.val);
+        inorder(root.right, list);
+        return list;
+    }
+}

src/数据结构/树/BST/在BST中查找两个节点之差的最小绝对值.java

@@ -0,0 +1,29 @@
+package 数据结构.树.BST;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 在BST中查找两个节点之差的最小绝对值 {
+    public int getMinimumDifference(TreeNode root) {
+        List<Integer> list = inorder(root, new ArrayList<>());
+        int min = Integer.MAX_VALUE;
+        for (int i = 1;i < list.size();i ++) {
+            if (Math.abs(list.get(i) - list.get(i - 1)) < min) {
+                min = Math.abs(list.get(i) - list.get(i - 1));
+            }
+        }
+        return min;
+    }
+    public List<Integer> inorder(TreeNode root, List<Integer> list) {
+        if (root == null) return list;
+        inorder(root.left, list);
+        list.add(root.val);
+        inorder(root.right, list);
+        return list;
+    }
+}

src/数据结构/树/BST/寻找BST中出现次数最多的节点.java

@@ -0,0 +1,45 @@
+package 数据结构.树.BST;
+
+import 数据结构.树.TreeNode;
+
+import java.util.*;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 寻找BST中出现次数最多的节点 {
+    public int[] findMode(TreeNode root) {
+        ArrayList<Integer> res = new ArrayList<>();
+        List<Integer> list = inorder(root, new ArrayList<>());
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int max = 0;
+        for (int i : list) {
+            if (map.containsKey(i)) {
+                map.put(i, map.get(i) + 1);
+                max = Math.max(max,map.get(i));
+            }else {
+                map.put(i,1);
+                max = Math.max(max,map.get(i));
+            }
+        }
+        Set<Integer> set = map.keySet();
+        for (int i : set) {
+            if (map.get(i) == max) {
+                res.add(i);
+            }
+        }
+        int []arr = new int[res.size()];
+        int index = 0;
+        for (int i : res) {
+            arr[index ++] = i;
+        }
+        return arr;
+    }
+    public List<Integer> inorder(TreeNode root, List<Integer> list) {
+        if (root == null) return list;
+        inorder(root.left, list);
+        list.add(root.val);
+        inorder(root.right, list);
+        return list;
+    }
+}

src/数据结构/树/BST/寻找BST的第k个元素.java

@@ -0,0 +1,25 @@
+package 数据结构.树.BST;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 寻找BST的第k个元素 {
+    public int kthSmallest(TreeNode root, int k) {
+        if (root == null) return 0;
+        List<Integer> list = inorder(root, new ArrayList<>());
+        return list.get(k - 1);
+    }
+
+    public List<Integer> inorder(TreeNode root, List<Integer> list) {
+        if (root == null) return list;
+        inorder(root.left, list);
+        list.add(root.val);
+        inorder(root.right, list);
+        return list;
+    }
+}

src/数据结构/树/BST/把BST每个节点的值都加上比它大的节点的值.java

@@ -0,0 +1,20 @@
+package 数据结构.树.BST;
+
+import 数据结构.树.TreeNode;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 把BST每个节点的值都加上比它大的节点的值 {
+    //先遍历右子树，再遍历根节点，再遍历左子树，就是从大到小遍历，
+    // 每个遍历到的值加上之前的和就是新的值
+    public TreeNode convertBST(TreeNode root) {
+        if (root == null) return null;
+        int sum = 0;
+        convertBST(root.right);
+        sum += root.val;
+        root.val = sum;
+        convertBST(root.left);
+        return root;
+    }
+}

src/数据结构/树/遍历/间隔遍历.java renamed to src/数据结构/树/层次遍历/间隔遍历.java

@@ -1,4 +1,4 @@
-package 数据结构.树.遍历;
+package 数据结构.树.层次遍历;
 
 import 数据结构.树.TreeNode;
 

src/数据结构/树/遍历/中序非递归.java

@@ -0,0 +1,40 @@
+package 数据结构.树.遍历;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 中序非递归 {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        if (root == null) return new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        List<Integer> list = new ArrayList<>();
+        TreeNode p = root;
+        stack.push(p);
+        //p.left代表新进栈的值，stack里的是原来待遍历的值，两边都为空时说明遍历结束。
+        while (p.left != null || !stack.isEmpty()) {
+            //先把左子树的节点进栈。
+            while (p.left != null) {
+                p = p.left;
+                stack.push(p);
+            }
+            //左下角节点出栈并访问，如果他有右子树，右子树进栈，并且退出循环
+            //进入第一个环节，将该右子树节点的所有左节点进栈，以此类推即可完成。
+            while (!stack.isEmpty()) {
+                TreeNode t = stack.pop();
+                list.add(t.val);
+                if (t.right != null) {
+                    stack.push(t.right);
+                    p = t.right;
+                    break;
+                }
+            }
+        }
+        return list;
+    }
+}

src/数据结构/树/遍历/先序非递归.java

@@ -0,0 +1,30 @@
+package 数据结构.树.遍历;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 先序非递归 {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        if (root == null) return new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        List<Integer> list = new ArrayList<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode t = stack.pop();
+            list.add(t.val);
+            if (t.right != null) {
+                stack.push(t.right);
+            }
+            if (t.left != null) {
+                stack.push(t.left);
+            }
+        }
+        return list;
+    }
+}

src/数据结构/树/遍历/后序非递归.java

@@ -0,0 +1,31 @@
+package 数据结构.树.遍历;
+
+import 数据结构.树.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Created by 周杰伦 on 2018/4/25.
+ */
+public class 后序非递归 {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        if (root == null) return new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        List<Integer> list = new ArrayList<>();
+        recur(stack, root);
+        while (!stack.isEmpty()) {
+            list.add(stack.pop().val);
+        }
+        return list;
+    }
+
+    public void recur (Stack<TreeNode> stack, TreeNode root) {
+        if (root == null) return;
+        stack.push(root);
+        recur(stack, root.right);
+        recur(stack, root.left);
+        return;
+    }
+}