devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【数据结构】二叉树前中后层序遍历代码实现以及各种操作与二叉树OJ题目

作者：Monodyee | 2024-04-17 09:32:57

赞

踩

【数据结构】二叉树前中后层序遍历代码实现以及各种操作与二叉树OJ题目

目录

一、二叉树的遍历

1、前序遍历

2、后续遍历

3、中序遍历

二、二叉树简单的操作

1、计算节点个数

1.二叉树所有节点个数

2.二叉树叶子节点个数

3.二叉树第K层节点个数

2、二叉树的高度

3、二叉树是否存在key

1.二叉树中是否存在key

2.寻找二叉树中key节点

三、二叉树OJ题目

1、力扣OJ：相同的树

2、力扣OJ：另一颗树的子树

3、力扣OJ：平衡二叉树

4、力扣OJ：对称二叉树

5、力扣OJ：层序遍历

6、牛客OJ：完全二叉树

一、二叉树的遍历

1、前序遍历

二叉树的前序遍历，顾名思义就是将根节点放在最前面进行遍历，也就是先遍历跟节点，然后再遍历左节点，最后右节点。如下图，按照前序遍历对这棵树进行遍历，我们先要遍历跟节点，然后左子树最后右子树 1-》2 -》4 -》8 -》5 -》9 -》 3 -》6 -》 7

144. 二叉树的前序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-preorder-traversal/

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public List<Integer> preorderTraversal(TreeNode root) {
  18.         // 1. 创建List
  19.         List<Integer> res = new ArrayList<>();
  20.         // 2. 判断如果为空则直接返回
  21.         if (root == null) {
  22.             return res;
  23.         }
  24.  
  25.         // 3. 先将根节点的值存入List
  26.         res.add(root.val);
  27.         // 4. 再去遍历他的左子树，将遍历的结果存入List
  28.         res.addAll(preorderTraversal(root.left));
  29.         // 5. 最后遍历右子树，再将结果存入List
  30.         res.addAll(preorderTraversal(root.right));
  31.         // 6. 最后返回
  32.         return res;
  33.     }
  34. }

2、后序遍历

与前序遍历不同的是后序遍历是先遍历左节点然后右节点最后遍历根节点

145. 二叉树的后序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-postorder-traversal/

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public List<Integer> postorderTraversal(TreeNode root) {
  18.         // 1. 创建List
  19.         List<Integer> res = new ArrayList<>();
  20.         // 2. 如果根节点为空则直接返回
  21.         if (root == null) {
  22.             return res;
  23.         }
  24.  
  25.         // 3. 遍历左子树并将结果存入List
  26.         res.addAll(postorderTraversal(root.left));
  27.         // 4. 遍历右子树并将结果存入List
  28.         res.addAll(postorderTraversal(root.right));
  29.         // 5. 最后遍历根节点
  30.         res.add(root.val);
  31.         // 6. 返回List
  32.         return res;
  33.     }
  34. }

3、中序遍历

中序遍历就是先遍历左节点，然后遍历根节点，最后再遍历右节点

94. 二叉树的中序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-inorder-traversal/

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public List<Integer> inorderTraversal(TreeNode root) {
  18.         // 1. 创建List存储数据
  19.         List<Integer> res = new ArrayList<>();
  20.         // 2. 如果根节点为空则直接返回res
  21.         if (root == null) {
  22.             return res;
  23.         }
  24.  
  25.         // 3. 先遍历左子树，将左子树的数据存入List
  26.         res.addAll(inorderTraversal(root.left));
  27.         // 4. 再遍历根节点
  28.         res.add(root.val);
  29.         // 5. 最后遍历右子树
  30.         res.addAll(inorderTraversal(root.right));
  31.         // 6. 返回数据
  32.         return res;
  33.     }
  34. }

二、二叉树简单的操作

1、计算节点个数

1.二叉树所有节点个数

在计算节点个数的时候，采用子问题法将二叉树看作若干个子二叉树，则节点个数=当前节点的左子树个数+右子树节点个数+1，此时我们只需要进行递归遍历即可

  1.     public int size(TreeNode root) {
  2.         // 1. 如果根节点为空则返回0
  3.         if (root == null) {
  4.             return 0;
  5.         }
  6.         
  7.         // 2. 节点个数 = 左子树节点个数 + 右子树节点个数 + 1（自身）
  8.         return size(root.left) + size(root.right) + 1;
  9.     }

2.二叉树叶子节点个数

与上树不同的是，我们只需计算叶子节点个数即可，那么叶子节点有什么特点呢，他的左右节点都为null，根据这一特点，我们可以知道一颗二叉树的叶子节点个数就 = 左子树叶子节点个数 + 右子树叶子节点个数

  1.     public int leafSize(TreeNode root) {
  2.         // 1. 如果根节点为空则返回0
  3.         if (root == null) {
  4.             return 0;
  5.         }
  6.         
  7.         // 2. 如果该节点是叶子节点 则返回0
  8.         if (root.left == null && root.right == null) {
  9.             return 1;
  10.         }
  11.         
  12.         // 3. 叶子节点 = 左子树叶子节点个数 + 右子树叶子节点个数
  13.         return leafSize(root.left) + leafSize(root.right);
  14.     }

3.二叉树第K层节点个数

我们在遍历整个树的过程中，第k层节点的个数 = 左子树第k层的个数 + 右子树第k层的个数

  1.     public int getKSize(TreeNode root, int k) {
  2.         // 1. 如果根节点是空则返回0
  3.         if (root == null) {
  4.             return 0;
  5.         }
  6.         
  7.         // 2. 如果此时是第k层节点，则返回1
  8.         if (k == 1) {
  9.             return 1;
  10.         }
  11.  
  12.         // 3. 第k层节点个数 = 左子树k层个数 + 右子树k层个数
  13.         return getKSize(root.left,k - 1) + getKSize(root.right, k - 1);
  14.     }

2、二叉树的高度

二叉树的高度其实就是左子树与右子树两个树的最大高度+1，而左子树的高度也就是左子树的左子树与左子树的右子树高度最大值+1

  1.     public int height(TreeNode root) {
  2.         // 1. 如果根节点为空则返回0
  3.         if (root == null) {
  4.             return 0;
  5.         }
  6.         
  7.         // 2. 树的高度 = max（左子树高度，右子树高度） + 1
  8.         return Math.max(height(root.left),height(root.right)) + 1;
  9.     }

3、二叉树是否存在key

1.二叉树中是否存在key

二叉树中是否存在key，我们可以在遍历的时候进行判断，如果存在则返回，只要左子树或者右子树中的一个有就存在

  1.     public boolean contains(TreeNode root, int key) {
  2.         // 如果根节点为空，则返回false
  3.         if (root == null) {
  4.             return false;
  5.         }
  6.  
  7.         // 如果相同则存在
  8.         if (root.val == key) {
  9.             return true;
  10.         }
  11.  
  12.         return contains(root.left,key) || contains(root.right,key);
  13.     }

2.寻找二叉树中key节点

在上面操作的基础上，我们如果发现这个节点后可直接将该节点进行返回

  1.     public TreeNode find(TreeNode root, int key) {
  2.         // 1. 如果根节点为空则不存在
  3.         if (root == null) {
  4.             return null;
  5.         }
  6.  
  7.         // 2. 如果找到则直接返回该节点
  8.         if (root.val == key) {
  9.             return root;
  10.         }
  11.  
  12.         // 3. 遍历左子树寻找该节点
  13.         TreeNode left = find(root.left,key);
  14.         if (left != null) {
  15.             // 3.1 找到则返回
  16.             return left;
  17.         }
  18.  
  19.         // 4. 遍历右子树寻找该节点
  20.         TreeNode right = find(root.right,key);
  21.         if (right != null) {
  22.             // 4.1 找到则返回
  23.             return right;
  24.         }
  25.  
  26.         // 5. 走到此处说明左子树与右子树都没有，则返回null
  27.         return null;
  28.     }

三、二叉树OJ题目

1、力扣OJ：相同的树

100. 相同的树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/same-tree/

判断两颗二叉树是否相同，我们只需在遍历时判断这两棵树是否相同，可能存在以下几种情况 

 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public boolean isSameTree(TreeNode p, TreeNode q) {
  18.         // 1. 如果都为空则相同
  19.         if (p == null && q == null) return true;
  20.  
  21.         // 2. 如果一个有节点 一个没有则不相同
  22.         if (p == null && q != null || q == null && p != null) return false;
  23.  
  24.         // 3. 如果节点的值不同,则两个树不相同
  25.         if (p.val != q.val) return false;
  26.  
  27.         // 4. 此时说明根节点相同，还需要满足左子树相同并且右子树也相同
  28.         return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
  29.     }
  30. }

2、力扣OJ：另一颗树的子树

572. 另一棵树的子树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/subtree-of-another-tree/

 

我们需要拿着子树与二叉树的根节点进行比较，看是否是相同的树，如果不是则与他的左子树进行比较，如果也不是则与他的右子树进行比较，以此类推，所有此处我们需要使用上一题的代码 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public boolean isSameTree(TreeNode p,TreeNode q) {
  18.          // 1. 如果都为空则相同
  19.         if (p == null && q == null) return true;
  20.  
  21.         // 2. 如果一个有节点 一个没有则不相同
  22.         if (p == null && q != null || q == null && p != null) return false;
  23.  
  24.         // 3. 如果节点的值不同,则两个树不相同
  25.         if (p.val != q.val) return false;
  26.  
  27.         // 4. 此时说明根节点相同，还需要满足左子树相同并且右子树也相同
  28.         return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
  29.     }
  30.     public boolean isSubtree(TreeNode root, TreeNode subRoot) {
  31.         // 1. 如果两个树其中一个是空则返回false
  32.         if (root == null || subRoot == null) return false;
  33.  
  34.         // 2. 只要他与根节点 或者 左子树 或者 右子树 其中一个树相同，则他就是子树
  35.         return isSameTree(root,subRoot) || isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
  36.     }
  37. }

3、力扣OJ：平衡二叉树

110. 平衡二叉树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/balanced-binary-tree/

以下是对平衡二叉树的定义 

那么判断一棵树是否是平衡二叉树，只需要根节点是平衡二叉树且他的左右子树都是平衡二叉树即可，因为需要判断左右子树的高度差，所有我们需要将前面求树的高度的代码用在此处 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     private int maxDepth(TreeNode root) {
  18.         if (root == null) {
  19.             return 0;
  20.         }
  21.  
  22.         return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
  23.     }
  24.  
  25.     public boolean isBalanced(TreeNode root) {
  26.         // 1. 如果根节点为空则返回真
  27.         if (root == null) {
  28.             return true;
  29.         }
  30.  
  31.         // 2. 根节点满足 && 左右子树满足
  32.         return Math.abs(maxDepth(root.left) - maxDepth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
  33.     }
  34. }

 但是上述代码的时间复杂度O(n^2)，那么可以优化上述代码吗，我们在上述代码中在求左右子树高度的时候其实可以在递归遍历的时候进行处理，当求高度递归过程中发现存在根节点的左右子树高度差不满足<=1时就可返回一个负值表示，该二叉树中存在不平衡的子树，进而根据求高度时的返回值来判断是否是平衡二叉树了。这种实现方式时间复杂度则为O(n)

 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     private int maxDepth(TreeNode root) {
  18.         // 1. 如果根节点为空则高度为0
  19.         if (root == null) {
  20.             return 0;
  21.         }
  22.  
  23.         // 2. 计算左右子树高度
  24.         int left = maxDepth(root.left);
  25.         int right = maxDepth(root.right);
  26.         // 3. 判断是否满足平衡二叉树
  27.         if (left != -1 && right != -1 &&Math.abs(left - right) <= 1) {
  28.             return Math.max(left,right) + 1;
  29.         } else {
  30.             // 3.1 不满足则返回-1
  31.             return -1;
  32.         }
  33.     }
  34.  
  35.     public boolean isBalanced(TreeNode root) {
  36.         // 1. 如果根节点为空则返回真
  37.         if (root == null) {
  38.             return true;
  39.         }
  40.  
  41.         // 2. 根据求高度时返回值判断
  42.         return maxDepth(root) >= 0;
  43.     }
  44. }

4、力扣OJ：对称二叉树

101. 对称二叉树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/symmetric-tree/

我们只需要判断根节点的左右子树是否对称即可 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public boolean isSymmetric(TreeNode root) {
  18.         // 1. 处理特殊情况
  19.         if (root == null) {
  20.             return true;
  21.         }
  22.         
  23.         // 2. 只要左子树与右子树对称即可
  24.         return isSymmetric(root.left,root.right);
  25.     }
  26.  
  27.     private boolean isSymmetric(TreeNode root1,TreeNode root2) {
  28.         // 1. 如果两颗树都为空则对称
  29.         if (root1 == null && root2 == null) return true;
  30.  
  31.         // 2. 如果一棵树为空另一颗树不为空则不对称
  32.         if (root1 == null && root2 != null || root1 != null && root2 == null) return false;
  33.  
  34.         // 3. 如果值不相同也不对称
  35.         if (root1.val != root2.val) return false;
  36.  
  37.         // 4. 最后递归判断root1的左子树与root2的右子树，root1的右子树与root2的左子树是否相同
  38.         return isSymmetric(root1.left,root2.right) && isSymmetric(root1.right,root2.left);
  39.     }
  40. }

5、力扣OJ：层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-level-order-traversal/二叉树的层序遍历，此处我们使用队列来进行处理

 

 

 

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     public List<List<Integer>> levelOrder(TreeNode root) {
  18.         // 1. 如果根节点为空则直接返回
  19.         List<List<Integer>> res = new ArrayList<>();
  20.         if (root == null) {
  21.             return res;
  22.         }
  23.  
  24.         // 2. 将根节点存入队列
  25.         Queue<TreeNode> queue = new LinkedList<>();
  26.         queue.offer(root);
  27.  
  28.         // 3. 循环处理
  29.         while (!queue.isEmpty()) {
  30.             // 3.1 计算该层元素个数
  31.             int size = queue.size();
  32.             List<Integer> row = new ArrayList<>();
  33.  
  34.             // 3.2 开始将该层元素存入row，并将下一层元素存入queue
  35.             while (size-- != 0) {
  36.                 // 3.2.1 弹出队顶元素
  37.                 TreeNode top = queue.poll();
  38.                 // 3.2.2 将值存入row
  39.                 row.add(top.val);
  40.                 // 3.2.3 将下一层节点存入queue
  41.                 if (top.left != null) queue.offer(top.left);
  42.                 if (top.right != null) queue.offer(top.right);
  43.             }
  44.  
  45.             // 3.3 将row存入res
  46.             res.add(row);
  47.         }
  48.  
  49.         // 4. 返回
  50.         return res;
  51.     }
  52. }

6、牛客OJ：完全二叉树

判断是不是完全二叉树_牛客题霸_牛客网 (nowcoder.com)icon-default.png?t=N6B9https://www.nowcoder.com/practice/8daa4dff9e36409abba2adbe413d6fae?tpId=196&tqId=39379&ru=/exam/oj

以上是对完全二叉树的定义，我们此处也可以使用队列来处理，按照层序遍历的方法进行处理，不过在存入根节点的左右子树时不进行null值判断，也就是将null值也存入，最后通过判断队列里的元素是否全是null来判断是否是完全二叉树，如果是完全二叉树，按照层序遍历方式处理完队列中剩余元素全是null，而如果不是完全二叉树则不仅仅只要null 

 

 

 

 

上述 以不完全二叉树进行举例，可将完全二叉树进行上述操作，发现结果中队列里全为null

  1. import java.util.*;
  2.  
  3. /*
  4.  * public class TreeNode {
  5.  *   int val = 0;
  6.  *   TreeNode left = null;
  7.  *   TreeNode right = null;
  8.  *   public TreeNode(int val) {
  9.  *     this.val = val;
  10.  *   }
  11.  * }
  12.  */
  13.  
  14. public class Solution {
  15.     /**
  16.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
  17.      *
  18.      * 
  19.      * @param root TreeNode类 
  20.      * @return bool布尔型
  21.      */
  22.     public boolean isCompleteTree (TreeNode root) {
  23.         // 1. 特殊处理
  24.         if (root == null) {
  25.             return true;
  26.         }
  27.  
  28.         // 2. 创建队列，将根节点存入队列
  29.         Queue<TreeNode> queue = new LinkedList<>();
  30.         queue.offer(root);
  31.  
  32.         // 3. 开始操作
  33.         while (!queue.isEmpty()) {
  34.             // 3.1 弹出队首元素
  35.             TreeNode top = queue.poll();
  36.             if (top != null) {
  37.                 // 3.1.2 将左右节点存入
  38.                 queue.offer(top.left);
  39.                 queue.offer(top.right);
  40.             } else {
  41.                 // 3.1.3 出现null 结束循环
  42.                 break;
  43.             }
  44.         }
  45.  
  46.         // 4. 开始判断队列中是否全是null
  47.         while (!queue.isEmpty()) {
  48.             TreeNode top = queue.peek();
  49.             if (top != null) {
  50.                 return false;
  51.             } else {
  52.                 queue.poll();
  53.             }
  54.         }
  55.  
  56.         return true;
  57.     }
  58. }

 后续题目正在补充中……

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号