Leetcode 樹的遍歷

1、Same Tree
鏈接：https://leetcode.com/problems/same-tree/
思路：遞歸思想

    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null)
            return true;
        if((p == null && q != null) || (p != null && q == null) || (p.val != q.val))
            return false;
        return isSameTree(p.left,q.left) && isSameTree(p.right, q.right);
    }

2、Binary Tree Preorder Traversal
鏈接：https://leetcode.com/problems/binary-tree-preorder-traversal/
思路：所有左子樹節點入棧，保存，出棧，訪問右子樹

//非遞歸
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack  = new Stack();
        TreeNode tree = root;
        while(tree != null  ||  !stack.isEmpty()){
            if(tree != null){
                stack.push(tree);
                list.add(tree.val);
                tree = tree.left;//遍歷左子樹
            }else{
                tree = stack.pop();//退棧
                tree = tree.right;//遍歷右子樹
            }
        }
        return list;
    }

    //遞歸解
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            list.add(root.val);
            list.addAll(preorderTraversal(root.left));
            list.addAll(preorderTraversal(root.right));
        }
        return list;
    }

3、Binary Tree Inorder Traversal
鏈接：https://leetcode.com/problems/binary-tree-inorder-traversal/
思路：先將根節點壓入棧，然後再將其所有左子結點壓入棧，然後取出棧頂節點，保存，訪問右子樹

//非遞歸
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack  = new Stack();
        TreeNode tree = root;
        while(tree != null || !stack.isEmpty()){
            if(tree != null){
                stack.push(tree);
                tree = tree.left;//遍歷左子樹
            }else{
                tree = stack.pop();//退棧
                list.add(tree.val);
                tree = tree.right;//遍歷右子樹
            }
        }
        return list;
    }

//遞歸
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            list.addAll(inorderTraversal(root.left));
            list.add(root.val);
            list.addAll(inorderTraversal(root.right));
        }
        return list;
    }

4、Binary Tree Postorder Traversal
鏈接：https://leetcode.com/problems/binary-tree-postorder-traversal/
思路：採用LinkedList，可以在list頭部插入；先序遍歷的逆

//非遞歸
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode tree = root;
        while (tree != null || stack.size() > 0) {
            if (tree != null) {
                list.addFirst(tree.val);
                stack.push(tree);
                tree = tree.right;
            } else {
                tree = stack.pop();
                tree = tree.left;
            }
        }
        return list;
    }

//遞歸
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            list.addAll(postorderTraversal(root.left));
            list.addAll(postorderTraversal(root.right));
            list.add(root.val);
        }
        return list;
    }

5、Binary Tree Level Order Traversal
鏈接：https://leetcode.com/problems/binary-tree-level-order-traversal/
思路：使用隊列進行樹的層次遍歷（廣度優先搜索），每層單獨輸出，使用for循環來實現。

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode tree = queue.poll();
                list.add(tree.val);
                if(tree.left != null)
                    queue.add(tree.left);
                if(tree.right != null)
                    queue.add(tree.right);
            }
            result.add(list);
        }
        return result;
    }

6、Binary Tree Level Order Traversal II
鏈接：https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
思路：使用linkedlist來實現倒序層次輸出

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> result = new LinkedList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode tree = queue.poll();
                list.add(tree.val);
                if(tree.left != null)
                    queue.add(tree.left);
                if(tree.right != null)
                    queue.add(tree.right);
            }
            result.addFirst(list);
        }
        return result;
    }