二叉树前中后

Author: Your Name

note/0107/README.md

@@ -31,7 +31,8 @@ return its bottom-up level order traversal as:
 
 ## 思路 0
 
-题意是从下往上按层遍历二叉树，每一层是从左到右，按层遍历，很明显，宽搜第一时间符合，因为是从下往上，所以插入的时候每次插到链表头即可。
+题意是从下往上按层遍历二叉树，每一层是从左到右，按层遍历，很明显，宽搜第一时间符合
+因为是从下往上，所以插入的时候每次插到链表头即可。
 
 ```java
 /**

progress.txt

@@ -1,11 +1,28 @@
 easy :
-列表操作 21 83
+列表操作 21 83 104
 
 medium:
 
 hard:
 
+可以分为基础的数据结构，比如数组、链表、栈、队列、二叉树、堆的使用
+这几种常见的数据结构的基础操作一定要很熟悉，
+比如链表逆置、删除、获取第 K 个元素、判断是否有环等，
+二叉树翻转、深度遍历、层级遍历、求树深度、公共父节点等。
+
+已完成: 链表逆置, 删除, 获取第 K 个元素, 是否有环
+深度遍历, 求树深度,
+
+未完成：二叉树翻转
+
+算法是一定要复习的，在很多面试的过程中都会穿插算法题。面试的算法题一般不会很难，可以分为基础的数据结构
+比如数组、链表、栈、队列、二叉树、堆的使用，这几种常见的数据结构的基础操作一定要很熟悉
+比如链表逆置、删除、获取第 K 个元素、判断是否有环等，二叉树翻转、深度遍历、层级遍历、求树深度、公共父节点等。
+
+
+另一种是常见的搜索、排序算法，这两类算法出现频率很高，一定要知道它们常见的几种实现方式，比如排序方式有
+冒泡、快排、插入、归并、堆排序等。注意这里一定不要简单地去记忆算法实现，因为面试的时候可能不会直接
+让你写出对应的算法，会出一些使用搜索或者排序算法来实现的题目，
+这类题目你可以去 LeetCode 上通过标签过滤出来。
 
 
-可以分为基础的数据结构，比如数组、链表、栈、队列、二叉树、堆的使用，这几种常见的数据结构的基础操作一定要很熟悉，
-比如链表逆置、删除、获取第 K 个元素、判断是否有环等，二叉树翻转、深度遍历、层级遍历、求树深度、公共父节点等。

src/com/blankj/easy/_0083/Solution.java

@@ -109,6 +109,22 @@ public static ListNodeMe reverseList2(ListNodeMe current) {
         return pre;
     }
 
+    public static ListNodeMe reverseList3(ListNodeMe current) {
+        ListNodeMe next = null;
+        ListNodeMe pre = null;
+        while (current != null) {
+            // 保存next指针
+            next = current.next;
+            // 打断next指针,指向前一个节点
+            current.next = pre;
+
+            // 为下一次循环做准备, 将pre节点指向当前节点, 将当前节点指向下一个节点,进入下一次循环
+            pre = current;
+            current = next;
+        }
+        return pre;
+    }
+
     /**
      * 删除第index个元素, 从0开始  "[1,2,3,4,5,6,8,10]"  2
      * @param current

src/com/blankj/easy/_0104/Solution.java

@@ -2,6 +2,9 @@
 
 
 import com.blankj.structure.TreeNode;
+import com.blankj.structure.TreeNodeMe;
+
+import static java.lang.System.out;
 
 /**
  * <pre>
@@ -17,10 +20,44 @@ public int maxDepth(TreeNode root) {
         return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
     }
 
+    public static void main_author(String[] args) {
+        Solution solution = new Solution();
+//        System.out.println(solution.maxDepth(TreeNode.createTestData("[]")));
+        TreeNode rootNode = TreeNode.createTestData("[1,2,2,3,4,4,3]");
+        int depth = solution.maxDepth(rootNode);
+        out.println(depth);
+        TreeNode.print(rootNode);
+//        System.out.println(solution.maxDepth(TreeNode.createTestData("[9,-42,-42,null,76,76,null,null,13,null,13]")));
+    }
+
     public static void main(String[] args) {
         Solution solution = new Solution();
-        System.out.println(solution.maxDepth(TreeNode.createTestData("[]")));
-        System.out.println(solution.maxDepth(TreeNode.createTestData("[1,2,2,3,4,4,3]")));
-        System.out.println(solution.maxDepth(TreeNode.createTestData("[9,-42,-42,null,76,76,null,null,13,null,13]")));
+//        TreeNodeMe rootNode = TreeNodeMe.createTestData("[1,2,2,3,4,4,3,5,6]");
+        TreeNodeMe rootNode = TreeNodeMe.createTestData("[0,1,2,3,4]");
+        int depth = solution.maxDepthMe(rootNode);
+        out.println(depth);
+//        TreeNodeMe.print(rootNode);
+
+    }
+
+    /**
+     * 深度搜索
+     * 0 -> 1 -> 3 -> 3.left return 1  -> 3.right return 1-> max(1,1) ->
+     * 1.left return 2 -> 4 -> 4.left is null return 1 -> 4.right is null return 1 ->
+     * -> max(1, 1) - > 1.right return 2 -> max.(2, 2) return 2 ->
+     * 0.left return 3 -> 2 -> 2.left -> 2.left return 1 -> 2.right -> 2.right return 1
+     * -> max(1, 1) ->0.right return 2 -> max(3, 2) -> return 3
+     * @param root
+     * @return
+     */
+    public int maxDepthMe(TreeNodeMe root) {
+        if (root == null) {
+            return 0;
+        }
+        out.println("经过了此节点值为:" +root.value);
+        int leftDepth = maxDepthMe(root.left) + 1;
+        int rightDepth = maxDepthMe(root.right) + 1;
+        return Math.max(leftDepth, rightDepth);
     }
+
 }

src/com/blankj/easy/_0107/Solution.java

@@ -2,10 +2,13 @@
 
 
 import com.blankj.structure.TreeNode;
+import com.blankj.structure.TreeNodeMe;
 
 import java.util.LinkedList;
 import java.util.List;
 
+import static java.lang.System.out;
+
 /**
  * <pre>
  *     author: Blankj
@@ -17,24 +20,57 @@
 public class Solution {
     public List<List<Integer>> levelOrderBottom(TreeNode root) {
         List<List<Integer>> list = new LinkedList<>();
-        helper(list, root, 0);
+        helper2(list, root, 0);
         return list;
     }
 
     private void helper(List<List<Integer>> list, TreeNode root, int level) {
         if (root == null) return;
-        if (level >= list.size()) {
+        if (level >= list.size()) { // 每经过一层添加一个list
             list.add(0, new LinkedList<>());
         }
         helper(list, root.left, level + 1);
         helper(list, root.right, level + 1);
         list.get(list.size() - level - 1).add(root.val);
     }
 
+    private void helper2(List<List<Integer>> list, TreeNode root, int level) {
+        if (root == null) return;
+        if (level >= list.size()) { // 每经过一层添加一个list
+            list.add(0, new LinkedList<>());
+        }
+        helper2(list, root.left, level + 1);
+        helper2(list, root.right, level + 1);
+        out.print(root.val + " "); // 在这里控制(前中后,指的是中间节点的访问顺序)序
+        list.get(list.size() - level - 1).add(root.val);
+    }
+
+    public static void main2(String[] args) {
+        Solution solution = new Solution();
+//        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[]")));
+        List<List<Integer>> lists = solution.levelOrderBottom(TreeNode.createTestData("[1,2,2,3,4,4,3]"));
+//        out.println(lists);
+//        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[9,-42,-42,null,76,76,null,null,13,null,13]")));
+    }
+
     public static void main(String[] args) {
         Solution solution = new Solution();
-        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[]")));
-        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[1,2,2,3,4,4,3]")));
-        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[9,-42,-42,null,76,76,null,null,13,null,13]")));
+        List<List<Integer>> lists = solution.levelOrderBottomMe(TreeNodeMe.createTestData("[1,2,2,3,4,4,3]"));
+//        out.println(lists);
     }
+
+    public List<List<Integer>> levelOrderBottomMe(TreeNodeMe root) {
+        List<List<Integer>> list = new LinkedList<>();
+        helperMe(root);
+        return list;
+    }
+
+    private void helperMe(TreeNodeMe root) {
+        if (root == null) return;
+        out.print(root.value + " ");
+        helperMe(root.left);
+        helperMe(root.right);
+
+    }
+
 }

src/com/blankj/structure/TreeNode.java

@@ -28,14 +28,17 @@ public static TreeNode createTestData(String data) {
         if (data.equals("[]")) return null;
         data = data.substring(1, data.length() - 1);
         String[] split = data.split(",");
-        int len = len = split.length;
+        int len = split.length;
+        // 数组保存所有节点
         TreeNode[] treeNodes = new TreeNode[len];
-        data = data.substring(1, data.length() - 1);
+        // [1,2,2,3,4,4,3]
         for (int i = 0; i < len; i++) {
             if (!split[i].equals("null")) {
+                // 给节点赋值, 但是没有引用关系
                 treeNodes[i] = new TreeNode(Integer.valueOf(split[i]));
             }
         }
+        // 建立引用关系
         for (int i = 0; i < len; i++) {
             if (treeNodes[i] != null) {
                 int leftIndex = i * 2 + 1;

src/com/blankj/structure/TreeNodeMe.java

@@ -0,0 +1,73 @@
+package com.blankj.structure;
+
+public class TreeNodeMe {
+    public int value;
+    public TreeNodeMe left;
+    public TreeNodeMe right;
+
+    public TreeNodeMe(int value) {
+        this.value = value;
+    }
+
+    public static TreeNodeMe createTestData(String data) {
+        // [1,2,2,3,4,4,3]
+        data =  data.substring(1, data.length() - 1);
+        String[] split = data.split(",");
+        int len = split.length;
+        TreeNodeMe treeNodes[] = new TreeNodeMe[len];
+        // 给数组赋值
+        for (int i = 0; i < len; i++) {
+            treeNodes[i] = new TreeNodeMe(Integer.parseInt(split[i])); // 异常未捕获
+        }
+        // 建立引用关系
+        for (int i = 0; i < len; i++) {
+            int leftIndex = i * 2 + 1;
+            int rightIndex = leftIndex + 1;
+            if (leftIndex < len) {
+                treeNodes[i].left = treeNodes[leftIndex];
+            }
+            if (rightIndex < len) {
+                treeNodes[i].right = treeNodes[rightIndex];
+            }
+        }
+        return treeNodes[0];
+    }
+
+    private static final String space = "      ";
+
+    /**
+     * 竖向打印二叉树
+     *
+     * @param root 二叉树根节点
+     */
+    public static void print(TreeNodeMe root) {
+        print(root, 0);
+    }
+
+    private static void print(TreeNodeMe node, int deep) {
+        if (node == null) {
+            printSpace(deep);
+            System.out.println("#");
+            return;
+        }
+        print(node.right, deep + 1);
+        printSpace(deep);
+        printNode(node.value);
+        print(node.left, deep + 1);
+    }
+
+    private static void printSpace(int count) {
+        for (int i = 0; i < count; i++) {
+            System.out.printf(space);
+        }
+    }
+
+    private static void printNode(int val) {
+        StringBuilder res = new StringBuilder(val + "<");
+        int spaceNum = space.length() - res.length();
+        for (int i = 0; i < spaceNum; i++) {
+            res.append(" ");
+        }
+        System.out.println(res);
+    }
+}