力扣—二叉树前中后遍历：递归+迭代

最新推荐文章于 2022-11-05 20:46:37 发布

丢丢diu丢

最新推荐文章于 2022-11-05 20:46:37 发布

阅读量169

点赞数

分类专栏：力扣刷题思考文章标签：二叉树 leetcode 算法

本文链接：https://blog.csdn.net/m0_38057941/article/details/115751603

版权

二叉树遍历递归迭代算法

关键词由CSDN通过智能技术生成

力扣刷题思考专栏收录该内容

44 篇文章 0 订阅

订阅专栏

1.前序遍历

1.递归

public List<Integer> preOrder(TreeNode root){
        List<Integer> list = new LinkedList<>();
        if(root==null){
            return list;
        }
        list.add(root.val);
        list.addAll(preOrder(root.left));
        list.addAll(preOrder(root.right));
        return list;
    }

2.迭代

public List<Integer> preOrderLoop(TreeNode root){
        List<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root!=null){
            stack.push(root);
        }

        while(!stack.isEmpty()){
            TreeNode current = stack.pop();
            list.add((Integer) current.val);
            if(current.right!=null){
                stack.push(current.right);
            }
            if(current.left!=null){
                stack.push(current.left);
            }
        }
        return list;
}

2.中序遍历

1.递归

public List<Integer> midOrder(TreeNode root){
        List<Integer> list = new LinkedList<>();
        if(root==null){
            return list;
        }
        list.addAll(midOrder(root.left));
        list.add(root.val);
        list.addAll(midOrder(root.right));

        return list;
    }

2.迭代

public List<Integer> midOrderLoop(TreeNode root){
        List<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode current = root;
        while(current!=null){
            stack.push(current);
            current = current.left;
        }

        while(!stack.isEmpty()){
            TreeNode temp = stack.pop();
            list.add(temp.val);
            TreeNode node = temp.right;
            while(node!=null){
                stack.push(node);
                node = node.left;
            }
        }

        return list;
}

3.后序遍历

1.递归

public List<Integer> backOrder(TreeNode root){
        List<Integer> list = new LinkedList<>();
        if(root==null){
            return list;
        }
        list.addAll(backOrder(root.left));
        list.addAll(backOrder(root.right));
        list.add(root.val);

        return list;
    }

2.迭代

public List<Integer> backOrderLoop(TreeNode root){
        LinkedList<Integer> list = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root!=null){
            stack.push(root);
        }

        while(!stack.isEmpty()){
            TreeNode temp = stack.pop();
            list.addFirst((Integer)temp.val);
            if(temp.left!=null){
                stack.push(temp.left);
            }
            if(temp.right!=null){
                stack.push(temp.right);
            }
        }
        return list;
    }