Binary Tree Inorder/Preorder/Postorder Traversal(Java)

最新推荐文章于 2024-08-14 16:51:40 发布

原创最新推荐文章于 2024-08-14 16:51:40 发布 · 538 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

79 篇文章

订阅专栏

本文介绍了二叉树的递归及迭代遍历方法，包括前序、中序和后序遍历，并提供了详细的Java代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

注：此博客不再更新，所有最新文章将发表在个人独立博客limengting.site。分享技术，记录生活，欢迎大家关注

Given a binary tree, return the inorder traversal of its nodes’ values.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

For example:
Given binary tree [1,null,2,3],

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

代码1：Recursive solution（递归）

// 中序遍历 inorder traversal
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }
    
    private void inorder(TreeNode root, List<Integer> res) {
        if (root == null) return;
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

// 先序遍历 preorder traversal
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preorder(root, res);
        return res;
    }
    private void preorder(TreeNode root, List<Integer> res) {
        if (root == null) return;
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

// 后序遍历 
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }
    private void postorder(TreeNode root, List<Integer> res) {
        if (root == null) return;
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

代码2：Iterative solution using stack（用堆栈迭代）

// 中序遍历 inorder traversal
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        TreeNode cur = root;
        
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                stack.add(cur); // 第一次遇到节点
                cur = cur.left;
            }
            
            if (!stack.empty()) {
                cur = stack.pop(); // 第二次遇到节点
                res.add(cur.val); // 第二次遇到才输出
                cur = cur.right;
            }
        }
        return res;
    }
}

// 先序遍历 preorder traversal
// 代码1： 在中序遍历上直接修改，还是用堆栈记录第一、二次遇到，只是第一次遇到就输出。
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        TreeNode cur = root;
        
        while (cur != null || !stack.empty()) {
            while (cur != null) {
                res.add(cur.val); // 第一次遇到就输出
                stack.add(cur); // 第一次遇到节点
                cur = cur.left;
            }
            
            if (!stack.empty()) {
                cur = stack.pop(); // 第二次遇到节点
                cur = cur.right;
            }
        }
        return res;
    }
}

// 代码2：不记录第一、二次遇到，第一次遇到就直接输出，而且记录其右节点，然后再倒着输出。
	public class Solution {
	    public List<Integer> preorderTraversal(TreeNode root) {
	        List<Integer> res = new ArrayList<>();
		    Stack<TreeNode> stack = new Stack<>();
	        TreeNode cur = root;
	        
	        while (cur != null) {
	            res.add(cur.val);
	            if (cur.right != null) {
	                stack.push(cur.right);
	            }
	            cur = cur.left;
	            if (cur == null && !stack.empty()) {
	                cur = stack.pop();
	            }
	        }
	        return res;
	    }
	}

// 后序遍历 postorder traversal
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> res = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        
        if (cur == null) return res;
        stack.push(cur);
        while (!stack.empty()) {
            cur = stack.pop();
            res.addFirst(cur.val);
            if (cur.left != null) 
                stack.push(cur.left);
            if (cur.right != null)
                stack.push(cur.right);
        }
        return res;
    }
}

其他人的总结：

//PRE ORDER TRAVERSE

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.add(p.val);  // Add before going to children
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            p = node.right;   
        }
    }
    return result;
}

//IN ORDER TRAVERSE

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            result.add(node.val);  // Add after all left children
            p = node.right;   
        }
    }
    return result;
}

//POST ORDER TRAVERSE

public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> result = new LinkedList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.addFirst(p.val);  // Reverse the process of preorder
            p = p.right;             // Reverse the process of preorder
        } else {
            TreeNode node = stack.pop();
            p = node.left;           // Reverse the process of preorder
        }
    }
    return result;
}