二叉树的遍历

最新推荐文章于 2022-06-08 00:20:12 发布

想做程序媛的小太阳

最新推荐文章于 2022-06-08 00:20:12 发布

阅读量234

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/weixin_41876155/article/details/80905220

leetcode 专栏收录该内容

10 篇文章

订阅专栏

很很很久没刷leetcode，又开始了要找不到工作的焦虑感，从今天开始，重拾刷题更博客的生活！

二叉树的遍历老生常谈，面试也经常出现，从方法上讲分为递归方法和非递归方法，从类型上讲分为前序中序和后序，还有层序等等。

1. 二叉树的前序遍历（Leetcode 144）

a. 递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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;      
    }
}

这里，想说一下，List中add和addAll的区别：

add是将传入的参数作为当前List中的一个Item存储，即使你传入一个List也只会另当前的List增加1个元素；addAll是传入一个List，将此List中的所有元素加入到当前List中，也就是当前List会增加的元素个数为传入的List的大小。即addAll(Collection c)，add(int index,Elelemt e)。说白了，就是add后面的参数是一个元素，addAll后面的参数是一个list。

b. 非递归方法

思路：通过栈来实现存储节点，先在栈中存储右子树的节点，再存储并弹出左子树的节点

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            while(!stack.isEmpty()){
                TreeNode a = stack.pop();
                list.add(a.val);
                if(a.right != null){
                    stack.push(a.right);
                }
                if(a.left != null){
                    stack.push(a.left);
                }
            }           
        }
        return list;
    }       
}

2. 二叉树的中序遍历（Leetcode 94）

a. 递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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;      
    }
}

b. 非递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.pop();
            list.add(node.val);
            root = node.right;
        }
        return list;
    }
}

3. 二叉树的后序遍历（Leetcode 145）

a. 递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    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;        
    }
}

b. 非递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
        public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
		Stack<TreeNode> nodeStack = new Stack<>();
		Stack<Integer> nodeState = new Stack<>();
        //记录右节点是否已经访问过，1表示已经访问了，0表示未访问

		 
		if(root==null)
			 return res;
		 else {
			 nodeStack.push(root);
			 nodeState.push(0);
			 root=root.left;
		}		 

		 while(!nodeStack.isEmpty()){		 
			 while(root!=null)
			 {
				 nodeStack.push(root);
				 nodeState.push(0);
				 root=root.left;
			 }//当这个循环跳出的时候, 说明nodeStak栈顶的那个节点没有左节点			 

			 if(nodeState.peek()==1){
                 //如果这时候已经访问过右节点了, 这时候就可以访问根节点			 
				 res.add(nodeStack.pop().val);
				 nodeState.pop();//把根节点对应的状态值去除				 
			 }
			 else {//访问右节点
				root=nodeStack.peek().right;
				nodeState.pop();//更改状态值由0变1  
				nodeState.push(1);
			}
		 }
		 return res;      
    }
}

4. 二叉树的层序遍历

两个队列，一个队列保存当前要遍历的节点，另一个队列用于存储下次遍历用的节点。初始状态当前队列只有一个元素根节点。
然后弹出工作队列元素，如果有子节点，推入下次遍历用节点。当当前队列为空，切换2个队列的功能继续。
详情见图2.jpg

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        
        if(root == null)
            return ans;
        
        List<TreeNode> cur = new LinkedList<>();
        List<TreeNode> next = new LinkedList<>();
        List<TreeNode> tmp = new LinkedList<>();
        
        cur.add(root);
        while(!cur.isEmpty()){
            List<Integer> list = new LinkedList<>();
            while(!cur.isEmpty()){
                if(cur.get(0).left != null)
                    next.add(cur.get(0).left);
                if(cur.get(0).right != null)
                    next.add(cur.get(0).right);
                list.add(cur.get(0).val);
                cur.remove(0);
            }
            tmp = cur;
            cur = next;
            next = tmp;
            ans.add(list);
        }
        return ans;       
    }
}

5. 翻转二叉树 (Leetcode 226)

a. 递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null)
            return root;
        TreeNode node = root.left;
        root.left = invertTree(root.right);
        root.right = invertTree(node);
        return root;      
    }
}

b. 非递归方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null)
            return root;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            TreeNode tmp = node.left;
            node.left = node.right;
            node.right = tmp;
            if(node.left != null){
                stack.push(node.left);
            }
            if(node.right != null){
                stack.push(node.right);
            }
        }
        return root;
    }
}

6. 锯齿形层次遍历二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        
        if(root == null)
            return ans;
        
        Deque<TreeNode> cur = new LinkedList<>();
        Deque<TreeNode> next = new LinkedList<>();
        Deque<TreeNode> tmp = new LinkedList<>();
        
        cur.add(root);
        int i = 1;
        while(!cur.isEmpty()){
            List<Integer> list = new LinkedList<>();
            while(!cur.isEmpty()){
                if(i % 2 == 1){
                    if(cur.getFirst().left != null)
                        next.add(cur.getFirst().left);
                    if(cur.getFirst().right != null)
                        next.add(cur.getFirst().right);
                    list.add(cur.getFirst().val);
                    cur.removeFirst(); 

                }
                else{
                    if(cur.getLast().right != null)
                        next.addFirst(cur.getLast().right);  //addFirst相当于在add的相反位置加
                    if(cur.getLast().left != null)
                        next.addFirst(cur.getLast().left);
                    list.add(cur.getLast().val);
                    cur.removeLast(); 
                }                             
            }
            ++i;
            tmp = cur;
            cur = next;
            next = tmp;
            ans.add(list);
        }
        return ans;       
    }
}

7. 中序遍历和后序遍历构造二叉树 (Leetcode 106)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return buildTree1(inorder, postorder, 0, inorder.length, 0, postorder.length);
    }
    
    public TreeNode buildTree1(int[] inorder, int[] postorder, int instart, int inend, int poststart, int postend){
        if(instart >= inend)
            return null;
        int i = instart;
        while(i < inend){
            if(inorder[i] == postorder[postend - 1]){
                break;  //找到根节点
            }
            ++i;
        }
        TreeNode root = new TreeNode(inorder[i]);
        int left_len = i - instart;  //左子树元素数量
        root.left = buildTree1(inorder, postorder, instart, i, poststart, poststart + left_len);
        root.right = buildTree1(inorder, postorder, i + 1, inend, poststart + left_len, postend - 1);
        return root;
    }
}