数据结构——二叉树的相关oj题（二）

目录

实现二叉树的基本操作

LeetCode102. 二叉树的层序遍历

leetCode107. 二叉树的层序遍历 II

LeetCode110.给定一个二叉树，判断它是否是高度平衡的二叉树。

LeetCode572. 另一棵树的子树

LeetCode101. 对称二叉树

LeetCode100. 相同的树

LeetCode226. 翻转二叉树
 

---

实现二叉树的基本操作

public class BinaryTree {
 
    static class TreeNode {
        public char val;
        public TreeNode left;//左孩子的引用
        public TreeNode right;//右孩子的引用
 
        public TreeNode(char val) {
            this.val = val;
        }
    }
 
 
    /**
     * 创建一棵二叉树 返回这棵树的根节点
     * 暂且使用穷举的方式创建二叉树
     * @return
     */
    public TreeNode createTree() {
 
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');
 
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        //E.right = H;
        return A;
    }
 
    // 前序遍历
    public void preOrder(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }
 
    // 中序遍历
    void inOrder(TreeNode root) {
        if (root == null) return;
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
 
    // 后序遍历
    void postOrder(TreeNode root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }
 
    public static int nodeSize;
 
    /**
     * 获取树中节点的个数：遍历思路
     */
    void size(TreeNode root) {
        if (root == null) return;
        nodeSize++;
        size(root.left);
        size(root.right);
    }
 
    /**
     * 获取节点的个数：子问题的思路
     *
     * @param root
     * @return
     */int size2(TreeNode root) {
        if (root == null) return 0;
        return size2(root.left)
                + size2(root.right) + 1;
    }
 
 
    /*
     获取叶子节点的个数：遍历思路
     */
    public static int leafSize = 0;
 
    void getLeafNodeCount1(TreeNode root) {
        if (root == null) return;
        if (root.left == null && root.right == null) {
            leafSize++;
        }
        getLeafNodeCount1(root.left);
        getLeafNodeCount1(root.right);
    }
 
    /*
     获取叶子节点的个数：子问题
     */int getLeafNodeCount2(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
    }
 
    /*
    获取第K层节点的个数
     */int getKLevelNodeCount(TreeNode root, int k) {
        if (root == null) return 0;
        if (k == 1) return 1;
        return getKLevelNodeCount(root.left, k - 1) +
                getKLevelNodeCount(root.right, k - 1);
    }
 
    /*
     获取二叉树的高度
     时间复杂度：O(N)
     */int getHeight(TreeNode root) {
        if (root == null) return 0;
        int leftH = getHeight(root.left);
        int rightH = getHeight(root.right);
        return leftH > rightH ? leftH + 1 : rightH + 1;
    }
 
 
    // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, char val) {
        if (root == null) return null;
        if (root.val == val) return root;
 
        TreeNode ret = find(root.left, val);
        if (ret != null) {
            return ret;
        }
        ret = find(root.right, val);
        if (ret != null) {
            return ret;
        }
        return null;
    }
 
    //层序遍历
    void levelOrder(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }
 
 
    // 判断一棵树是不是完全二叉树
    boolean isCompleteTree(TreeNode root) {
        if (root == null) return false;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if (cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            } else {
                break;
            }
        }
        //第2次遍历队列 判断队列当中 是否存在非空的元素while (!queue.isEmpty()) {
            TreeNode cur = queue.peek();
            if (cur == null) {
                queue.poll();
            } else {
                return false;
            }
        }
        return true;
    }
}

LeetCode102. 二叉树的层序遍历

难度：中等

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

具体实现：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //访问一点个节点时，将当前节点的左子树先入队，再入队右子树
        //只有当子树不为空才入队，null不入队
    List<List<Integer>> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        //借助队列模拟层序遍历的过程
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> curList = new ArrayList<>();
            for(int i = 0;i < size; i++){
                TreeNode node = queue.poll();
                curList.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
            result.add(curList);
            }
            return result;
        }
        }

leetCode107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

 具体实现：

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
        if (root == null) {
            return levelOrder;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                TreeNode left = node.left, right = node.right;
                if (left != null) {
                    queue.offer(left);
                }
                if (right != null) {
                    queue.offer(right);
                }
            }
            levelOrder.add(0, level);
        }
        return levelOrder;
    }
    }

LeetCode110.给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内
• -104 <= Node.val <= 104

  class Solution {
      public boolean isBalanced(TreeNode root) {
     // base case
          if(root == null || root.left == null && root.right == null) {
              return true;
          }
          int leftHeight = height(root.left);
          int rightHeight = height(root.right);
          int abs = Math.abs(leftHeight - rightHeight);
          // 找反例
          if (abs > 1) {
              return false;
          }
          return isBalanced(root.left) && isBalanced(root.right);
      }
      public int height(TreeNode root) {
          // 1.base case
  //        if (root == null) {
  //            return 0;
  //        }
  //        // 总高度 = 1 + Math.max(左子树高度，右子树高度)
  //        return 1 + Math.max(height(root.left),height(root.right));
          return root == null ? 0 : 1 + Math.max(height(root.left),height(root.right));
      }
  
  }

  LeetCode572. 另一棵树的子树

  给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

  二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

  示例 1：

  

  输入：root = [3,4,5,1,2], subRoot = [4,1,2]
  输出：true
  

  示例 2：

  

  输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
  输出：false
  
  

  提示：

• root 树上的节点数量范围是 [1, 2000]
• subRoot 树上的节点数量范围是 [1, 1000]
• -104 <= root.val <= 104
• -104 <= subRoot.val <= 104

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
   // base case
        if (root == null && subRoot == null) {
            return true;
        }
        if (root == null || subRoot == null) {
            return false;
        }
        // 若当前以root为根的树和以subRoot为根的树是相同的树
        if (isSameTree(root,subRoot)) {
            return true;
        }
        // 要么在左子树中包含或者在右子树中包含即可~
        // 千万注意，左子树和右子树的判断，不是判断相同
        return isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
    }

    public boolean isSameTree(TreeNode p, TreeNode q) {
        // 1.base case
        if (p == null && q == null) {
            return true;
        }
        // 一个是空树一个非空
        if (p == null || q == null) {
            return false;
        }
        if (p.val != q.val) {
            return false;
        }
        // 继续判断左子树和右子树是否相同
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

LeetCode101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

class Solution {
    public boolean isSymmetric(TreeNode root) {
       if (root == null || root.left == null && root.right == null) {
            return true;
        }
        return isMirror(root.left,root.right);
    }
    // 判断两颗树t1和t2是否是轴对称相等的树
    private boolean isMirror(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) {
            return true;
        }
        if (t1 == null || t2 == null) {
            return false;
        }
        if (t1.val != t2.val) {
            return false;
        }
        return isMirror(t1.left,t2.right) && isMirror(t1.right,t2.left);
    }
}

LeetCode100. 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内
• -104 <= Node.val <= 104

  class Solution {
      public boolean isSameTree(TreeNode p, TreeNode q) {
   // 1.base case
          if (p == null && q == null) {
              return true;
          }
          // 一个是空树一个非空
          if (p == null || q == null) {
              return false;
          }
          if (p.val != q.val) {
              return false;
          }
          // 继续判断左子树和右子树是否相同
          return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
      }
  }

  LeetCode226. 翻转二叉树

  给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

  示例 1：

  

  输入：root = [4,2,7,1,3,6,9]
  输出：[4,7,2,9,6,3,1]
  

  示例 2：

  

  输入：root = [2,1,3]
  输出：[2,3,1]
  

  示例 3：

  输入：root = []
  输出：[]
  

  提示：

• 树中节点数目范围在 [0, 100] 内
• -100 <= Node.val <= 100

class Solution {
    public TreeNode invertTree(TreeNode root) {
 // base case
        if(root == null || root.left == null && root.right == null) {
            return root;
        }
        // 先递归的翻转左子树
        root.left = invertTree(root.left);
        // 再递归的翻转右子树
        root.right = invertTree(root.right);
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        return root;
    }
}