深度与广搜

Author: Your Name

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

@@ -4,8 +4,10 @@
 import com.blankj.structure.TreeNode;
 import com.blankj.structure.TreeNodeMe;
 
+import java.util.ArrayDeque;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Queue;
 
 import static java.lang.System.out;
 
@@ -53,24 +55,61 @@ public static void main2(String[] args) {
 //        System.out.println(solution.levelOrderBottom(TreeNode.createTestData("[9,-42,-42,null,76,76,null,null,13,null,13]")));
     }
 
+    /**
+     *        0
+     *      /  \
+     *     1    2
+     *    / \  / \
+     *   3  4 5  6
+     * @param args
+     */
     public static void main(String[] args) {
         Solution solution = new Solution();
-        List<List<Integer>> lists = solution.levelOrderBottomMe(TreeNodeMe.createTestData("[1,2,2,3,4,4,3]"));
+        TreeNodeMe treeNodes = TreeNodeMe.createTestData("[0,1,2,3,4,5,6]");
+        List<List<Integer>> lists = solution.depthSearch(treeNodes);
 //        out.println(lists);
+        solution.levelSearch(treeNodes);
     }
 
-    public List<List<Integer>> levelOrderBottomMe(TreeNodeMe root) {
+    public List<List<Integer>> depthSearch(TreeNodeMe root) {
         List<List<Integer>> list = new LinkedList<>();
-        helperMe(root);
+        out.print("深度搜索: ");
+        depth(root);
+        out.println();
         return list;
     }
 
-    private void helperMe(TreeNodeMe root) {
+    /**
+     * 这里就是深度遍历(也就是前序遍历)
+     * @param root
+     */
+    private void depth(TreeNodeMe root) {
         if (root == null) return;
         out.print(root.value + " ");
-        helperMe(root.left);
-        helperMe(root.right);
+        depth(root.left);
+        depth(root.right);
 
     }
 
+    /**
+     * 广度 0 1 2 3 4 5 6
+     * @param root
+     */
+    private void levelSearch(TreeNodeMe root) {
+        if (root == null) return;
+        Queue<TreeNodeMe> queue = new ArrayDeque();
+        queue.add(root);
+        out.print("广度搜索: ");
+        while (!queue.isEmpty()) {
+            TreeNodeMe header = queue.remove();
+            out.print(header.value + " ");
+            if (header.left != null) {
+                queue.add(header.left);
+            }
+            if (header.right != null) {
+                queue.add(header.right);
+            }
+        }
+    }
+
 }

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

@@ -0,0 +1,109 @@
+
+import java.util.ArrayDeque;
+import java.util.Stack;
+
+public class TreeTest {
+    static class TreeNode {
+        int value;
+        TreeNode left;
+        TreeNode right;
+
+        public TreeNode(int value) {
+            this.value = value;
+        }
+    }
+
+    TreeNode root;
+
+    public TreeTest(int[] array) {
+        root = makeBinaryTreeByArray(array, 1);
+    }
+
+    /**
+     * 采用递归的方式创建一颗二叉树
+     * 传入的是二叉树的数组表示法
+     * 构造后是二叉树的二叉链表表示法
+     */
+    public static TreeNode makeBinaryTreeByArray(int[] array, int index) {
+        if (index < array.length) {
+            int value = array[index];
+            if (value != 0) {
+                TreeNode t = new TreeNode(value);
+                array[index] = 0;
+                t.left = makeBinaryTreeByArray(array, index * 2);
+                t.right = makeBinaryTreeByArray(array, index * 2 + 1);
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 深度优先遍历，相当于先根遍历
+     * 采用非递归实现
+     * 需要辅助数据结构：栈
+     */
+    public void depthOrderTraversal() {
+        if (root == null) {
+            System.out.println("empty tree");
+            return;
+        }
+        //     ArrayDeque<TreeNode> stack=new ArrayDeque<TreeNode>();
+        // 0,13,65,5,97,25,0,37,22,0,4,28,0,0,32,0
+        Stack<TreeNode> stack = new Stack();   //也可以用栈实现
+        stack.push(root);
+        while (stack.isEmpty() == false) {
+            TreeNode node = stack.pop();
+            System.out.print(node.value + "    "); // 先访问自己
+            if (node.right != null) {
+                stack.push(node.right);
+            }
+            if (node.left != null) { // 最后访问左节点
+                stack.push(node.left);
+            }
+        }
+        System.out.print("\n");
+    }
+
+    /**
+     * 广度优先遍历
+     * 采用非递归实现
+     * 需要辅助数据结构：队列
+     */
+    public void levelOrderTraversal() {
+        if (root == null) {
+            System.out.println("empty tree");
+            return;
+        }
+        ArrayDeque<TreeNode> queue = new ArrayDeque<TreeNode>();
+        queue.add(root);
+        while (queue.isEmpty() == false) {
+            TreeNode node = queue.remove();
+            System.out.print(node.value + "    ");
+            if (node.left != null) {
+                queue.add(node.left);
+            }
+            if (node.right != null) {
+                queue.add(node.right);
+            }
+        }
+        System.out.print("\n");
+    }
+
+    /**
+     * 13
+     * /  \
+     * 65    5
+     * /  \    \
+     * 97  25   37
+     * /    /\   /
+     * 22   4 28 32
+     */
+    public static void main(String[] args) {
+        int[] arr = {0, 13, 65, 5, 97, 25, 0, 37, 22, 0, 4, 28, 0, 0, 32, 0};
+        TreeTest tree = new TreeTest(arr);
+        tree.depthOrderTraversal(); //深度优先: 深度就是前序 13    65    97    22    25    4    28    5    37    32
+        tree.levelOrderTraversal(); //广度优先:  13    65    5    97    25    37    22    4    28    32
+    }
+
+}