Li_阴宅

这个屌丝很懒，什么也没留下！

热门标签

LeetCode之Tree题目汇总_string to tree leetcode的基础

作者：Li_阴宅 | 2024-07-05 01:58:18

踩

string to tree leetcode的基础

Balanced Binary Tree

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

判断二叉树是否平衡，规则如下：

左子树深度和右子树深度相差不大于1

核心代码：

        return Math.abs(height(root.left) - height(root.right)) <= 1
                && isBalanced(root.left) && isBalanced(root.right);1
2

    public boolean isBalanced(TreeNode root) {

        if (root == null) {
            return true;
        }

        return Math.abs(height(root.left) - height(root.right)) <= 1
                && isBalanced(root.left) && isBalanced(root.right);

    }

    int height(TreeNode node) {

        if (node == null) {
            return 0;
        }

        return Math.max(height(node.left), height(node.right)) + 1;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Binary Tree Inorder Traversal

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

For example:
Given binary tree {1,#,2,3},

return [1,3,2].

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

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

    List<Integer> rt = new ArrayList<Integer>();

    public List<Integer> inorderTraversal(TreeNode root) {

        rt.clear();
        inorder(root);
        return rt;
    }

    void inorder(TreeNode node) {

        if (node == null) {
            return;
        }

        inorder(node.left);
        rt.add(node.val);
        inorder(node.right);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Binary Tree Preorder Traversal

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

For example:
Given binary tree {1,#,2,3},

return [1,2,3].

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

    public List<Integer> preorderTraversal(TreeNode root) {

        List<Integer> rt = new ArrayList<Integer>();

        if (root == null) {
            return rt;
        }

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;

        while (p != null || !stack.empty()) {

            while (p != null) {
                rt.add(p.val);
                stack.push(p);
                p = p.left;
            }

            if (!stack.empty()) {
                p = stack.pop();
                p = p.right;
            }
        }

        return rt;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Binary Tree Postorder Traversal

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

For example:
Given binary tree {1,#,2,3},

return [3,2,1].

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

    public class PostTreeNode {
   
        TreeNode node;
        boolean first;
    }

    public List<Integer> postorderTraversal(TreeNode root) {

        List<Integer> rt = new ArrayList<Integer>();

        if (root == null) {
            return rt;
        }

        Stack<PostTreeNode> stack = new Stack<PostTreeNode>();
        TreeNode p = root;
        PostTreeNode t;

        while (p != null || !stack.empty()) {

            while (p != null) {

                // 新建一个结点，这个结点包含一个布尔值first
                // 用来判断是否是第一次入栈
                PostTreeNode post = new PostTreeNode();
                post.node = p;
                post.first = true;
                stack.push(post);
                p = p.left;
            }

            if (!stack.empty()) {

                t = stack.pop();

                // 如果结点第一次出栈，再次入栈，将first置为false
                if (t.first == true) {
                    t.first = false;
                    stack.push(t);
                    p = t.node.right;
                } else {
                    rt.add(t.node.val);
                    p = null;
                }
            }
        }

        return rt;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]1
2
3
4
5

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

1. 通过统计每一行的结点数

定义两个变量，toBePrinted和nextLevel。

toBePrinted：当前待打印结点的数量
nextLevel：下一层的结点数量

通过Deque来进行统计。

2. 插入特殊结点

参考自：Binary Tree Level Order Traversal

通过插入特殊结点，来判断一层是否结束。这样做的好处是不用统计每一层结点数目。伪代码如下：

a queue stores [step0, step1, step2, ...]

queue.add(first step)

while queue is not empty

  current_step = queue.poll()

  // do something here with current_step
  // like counting

  foreah step in current_step can jump to
    queue.add(step)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

代码1：通过统计每一行的结点数：

    public List<List<Integer>> levelOrder(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.add(root);

        int toBePrinted = 1;
        int nextLevel = 0;

        List<Integer> level = new LinkedList<Integer>();

        while (!deque.isEmpty()) {

            TreeNode p = deque.poll();
            level.add(p.val);
            toBePrinted--;

            if (p.left != null) {
                deque.addLast(p.left);
                nextLevel++;
            }

            if (p.right != null) {
                deque.addLast(p.right);
                nextLevel++;
            }

            if (toBePrinted == 0) {
                toBePrinted = nextLevel;
                nextLevel = 0;
                rt.add(new ArrayList<Integer>(level));
                level.clear();
            }

        }

        return rt;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

代码2：插入特殊结点：

    public List<List<Integer>> levelOrder2(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        final TreeNode END = new TreeNode(0);

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        List<Integer> level = new LinkedList<Integer>();

        deque.add(root);
        deque.add(END);

        while (!deque.isEmpty()) {

            TreeNode p = deque.pop();

            if (p == END) {
                rt.add(new ArrayList<Integer>(level));
                level.clear();

                if (!deque.isEmpty()) {
                    deque.add(END);
                }
            } else {
                level.add(p.val);

                if (p.left != null) {
                    deque.add(p.left);
                }

                if (p.right != null) {
                    deque.add(p.right);
                }
            }
        }

        return rt;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its bottom-up level order traversal as:

[
  [15,7],
  [9,20],
  [3]
]1
2
3
4
5

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

参考：LeetCode 102 Binary Tree Level Order Traversal

只是在返回result前，加入一句话

Collections.reverse(result);1

    public List<List<Integer>> levelOrderBottom(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        final TreeNode END = new TreeNode(0);

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        List<Integer> level = new LinkedList<Integer>();

        deque.add(root);
        deque.add(END);

        while (!deque.isEmpty()) {

            TreeNode p = deque.pop();

            if (p == END) {
                rt.add(new ArrayList<Integer>(level));
                level.clear();

                if (!deque.isEmpty()) {
                    deque.add(END);
                }
            } else {
                level.add(p.val);

                if (p.left != null) {
                    deque.add(p.left);
                }

                if (p.right != null) {
                    deque.add(p.right);
                }
            }
        }

        Collections.reverse(rt);
        return rt;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Binary Tree Paths

Given a binary tree, return all root-to-leaf paths.

For example, given the following binary tree:

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/788864