leetcode_二叉树遍历总结_Java版

假期了继续刷刷leetcode吧！

前序，中序，后序递归实现

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans  = new ArrayList<Integer>();
        preorder(root,ans);
        return ans;
    }
    public void preorder(TreeNode root, List<Integer> ans)
    {
        if(root==null)  return ;
        ans.add(root.val);
        preorder(root.left,ans);
        preorder(root.right,ans);
    }
}

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans =new ArrayList<Integer>();
        inorder(root,ans);
        return ans;
    }
    public void inorder(TreeNode root,List<Integer> ans)
    {
        if(root==null)  return;
        inorder(root.left,ans);
        ans.add(root.val);
        inorder(root.right,ans);

    }
}

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans  = new ArrayList<Integer>();
        postorder(root,ans);
        return ans;
    }
    public void postorder(TreeNode root, List<Integer> ans)
    {
        if(root==null)  return;
        postorder(root.left,ans);
        postorder(root.right,ans);
        ans.add(root.val);
    }
}

非递归实现

1.前序遍历
以上图为例，1入栈，往左走，2入栈，4入栈，4出栈（此时root==null 但仍能进入外层循环，因为栈不空，跳过内层循环，2出栈，往右走 5入栈，5出栈，1出栈，3入栈，6入栈，6出，3出
因此前序遍历序列425163

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null||!stack.isEmpty()) {
            while (root != null) {
                ans.add(root.val);
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            root = root.right;
        }
        return ans;
    }
}

2.中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            ans.add(root.val);
            root = root.right;
        }
        return ans;
    }
}

3. 后序遍历
   

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null||!stack.isEmpty()) {
            while (root != null) {
                ans.add(root.val);
                stack.push(root);
                root = root.right;
            }
            root = stack.pop();
            root = root.left;
        }
        Collections.reverse(ans);
        return ans;
    }
}

层序遍历

首先层序遍历即基于BFS

void bfs(TreeNode root) {
    Queue<TreeNode> queue = new ArrayDeque<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll(); 
        if (node.left != null) {
            queue.add(node.left);
        }
        if (node.right != null) {
            queue.add(node.right);
        }
    }
}

ArrayDeque 是 Java 集合中双端队列的数组实现，LinkedList是双端队列的链表实现
在每一层遍历开始前，先记录队列中的结点数量 n（也就是这一层的结点数量），然后一口气处理完这一层的 n 个结点。

class Solution{
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null)   queue.add(root);
        while (!queue.isEmpty()) {
            int n = queue.size();//第一层size=1
            List<Integer> level = new ArrayList<>();
            //分层加入，
            for (int i = 0; i < n; i++) //第一层就循环2次，即把第二层的结点入队
            { 
                TreeNode node = queue.poll();//先把根结点出队
                level.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add(level);
        }
        return ans;
    }
}