二叉树的右视图这道算法题可以用递归解决的Java实现的代码

可以的，以下是Java实现的代码：

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        dfs(root, res, );
        return res;
    }
    
    private void dfs(TreeNode node, List<Integer> res, int depth) {
        if (node == null) return;
        if (depth == res.size()) res.add(node.val);
        dfs(node.right, res, depth + 1);
        dfs(node.left, res, depth + 1);
    }
}

这段代码可以求出二叉树的右视图。

相关问题

Java代码实现二叉树后根次序遍历的非递归算法

好的，以下是Java代码实现二叉树后根次序遍历的非递归算法：

import java.util.Stack;

class Node {
    int val;
    Node left, right;

    public Node(int val) {
        this.val = val;
        left = right = null;
    }
}

public class BinaryTree {
    Node root;

    public void postOrderTraversal() {
        if (root == null) {
            return;
        }

        Stack<Node> stack = new Stack<>();
        Node node = root;
        Node lastVisited = null;

        while (!stack.isEmpty() || node != null) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                Node peekNode = stack.peek();
                if (peekNode.right != null && lastVisited != peekNode.right) {
                    node = peekNode.right;
                } else {
                    lastVisited = stack.pop();
                    System.out.print(lastVisited.val + " ");
                }
            }
        }
    }

    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);

        System.out.println("Postorder traversal of binary tree is :");
        tree.postOrderTraversal();
    }
}

这里使用了一个栈 `stack` 和一个指针 `node`，首先将根节点赋值给 `node`，然后进入循环，当 `stack` 不为空或者 `node` 不为 null 时循环继续。对于每个节点，首先将其左子节点入栈，然后将指针 `node` 指向左子节点，直到最左边的子节点。当一个节点的左子节点为空时，从栈中弹出该节点并打印，然后将指针 `node` 指向该节点的右子节点。如果该节点的右子节点为空或者已经被访问过（即 `lastVisited == peekNode.right`），则说明该节点的右子树已经被遍历过了，可以将该节点弹出并打印。

上述代码的输出结果为：

Postorder traversal of binary tree is :
4 5 2 6 7 3 1

Java代码实现二叉树后根次序遍历的非递归算法。

好的，以下是Java代码实现二叉树后根次序遍历的非递归算法：

import java.util.Stack;

class Node {
    int data;
    Node left, right;

    public Node(int item) {
        data = item;
        left = right = null;
    }
}

class BinaryTree {
    Node root;

    void postOrder() {
        if (root == null)
            return;

        Stack<Node> stack1 = new Stack<>();
        Stack<Node> stack2 = new Stack<>();

        stack1.push(root);

        while (!stack1.isEmpty()) {
            Node temp = stack1.pop();
            stack2.push(temp);

            if (temp.left != null)
                stack1.push(temp.left);

            if (temp.right != null)
                stack1.push(temp.right);
        }

        while (!stack2.isEmpty())
            System.out.print(stack2.pop().data + " ");
    }

    public static void main(String args[]) {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
        tree.root.right.left = new Node(6);
        tree.root.right.right = new Node(7);

        System.out.println("Post order traversal of binary tree is :");
        tree.postOrder();
    }
}

这里使用了两个栈 `stack1` 和 `stack2`，首先将根节点压入 `stack1` 中。然后在 `stack1` 不为空时，弹出栈顶元素 `temp` 并将其压入 `stack2` 中，同时将 `temp` 的左右子节点压入 `stack1` 中。最后打印 `stack2` 中的元素即可得到后根次序遍历的结果。

上述代码的输出结果为：

Post order traversal of binary tree is :
4 5 2 6 7 3 1