二叉树与递归

二叉树与递归

• 求一个二叉树的最深高度（从根节点到某一个叶子节点的最长路径的长度）

  public class Solution {
      public int TreeDepth(TreeNode root) {
          if(root==null){
              return 0;
          }
          
          int leftTreeDepth=TreeDepth(root.left);
          int rightTreeDepth=TreeDepth(root.right);
          return Math.max(leftTreeDepth,rightTreeDepth)+1;
      }
  }
  

• 操作给定的二叉树，将其变换为源二叉树的镜像

  public class Solution {
      public void Mirror(TreeNode root) {
          if(root==null)
              return;
          
          TreeNode node=root.left;
          root.left=root.right;
          root.right=node;
          Mirror(root.left);
          Mirror(root.right);
      }
  }
  

• 输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

  public class Solution {
      private ArrayList<Integer> list=new ArrayList<Integer>();
      private ArrayList<ArrayList<Integer>> listAll=new ArrayList<ArrayList<Integer>>();
      public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
          if(root==null)
              return listAll;
          list.add(root.val);
          target-=root.val;
          //到达叶子节点而且剩余期望的target为0
          if(target==0&&root.left==null&&root.right==null){
              //这里一定要new一个 不能指向原来的list引用 原来的list会一直变化
              listAll.add(new ArrayList<Integer>(list));
          }
          FindPath(root.left,target);
          FindPath(root.right,target);
          //回溯到上一个节点
          list.remove(list.size()-1);
          return listAll;
      }
  }
  

• 给定一颗二叉树 返回所有从根节点到叶子节点的字符串

  输入:
  
     1
   /   \
  2     3
   \
    5
  
  输出: ["1->2->5", "1->3"]
  
  解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
  
  来源   LeetCode 257
  

  class Solution {
      List<String> listAll=new ArrayList<>();
      //用list动态的保存遍历寻找的结果
      List<Integer> list=new ArrayList<>();
      public List<String> binaryTreePaths(TreeNode root) {
          if(root==null)
              return listAll;
          
         list.add(root.val);
         //到达叶子节点的情况
         if(root.left==null&&root.right==null){
             int len=list.size()-1;
             //每次遍历到叶子节点 new一个字符串保存结果
             StringBuilder sb=new StringBuilder();
             for(int i=0;i<len;i++){
                 sb.append(list.get(i)).append("->");
             }
             sb.append(root.val);
             listAll.add(sb.toString());
         }
         binaryTreePaths(root.left);
         binaryTreePaths(root.right);
         //回溯到上一个节点
         list.remove(list.size()-1);
         return listAll; 
      }
  }
  

• 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先

  如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

  示例 1:
  
  输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
  输出: 6 
  解释: 节点 2 和节点 8 的最近公共祖先是 6。
  
  示例 2:
  
  输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
  输出: 2
  解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
  
  来源：力扣（LeetCode 235）
  

  class Solution {
      public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
          if(root==null)
              return null;
  		//情况一 p和q都比root的val值小
          if(p.val<root.val&&q.val<root.val){
              return lowestCommonAncestor(root.left,p,q);
          }
          //情况二 p和q都比root的val值大
          if(p.val>root.val&&q.val>root.val){
              return lowestCommonAncestor(root.right,p,q);
          }
  		//情况三 p和q的值一个大于val 一个小于val 或者p或q本身就是root节点
          //返回root节点
          return root;
      }
  }
  

• 给定一个二叉树，判断其是否是一个有效的二叉搜索树

  来源：（LeetCode -98）

  方法一 递归

  class Solution {
      public boolean isValidBST(TreeNode root) {
           //递归思路  限制每一个节点的值的范围
          return solve(root,Long.MIN_VALUE,Long.MAX_VALUE);
      }
      public boolean solve(TreeNode node,long lower,long upper){
          if(node==null)
              return true;
          if(node.val<=lower||node.val>=upper)
              return false;
          return solve(node.left,lower,node.val)&&solve(node.right,node.val,upper);
      }
  }
  

  方法二 利用二分搜索树的中序遍历是有序数组

  class Solution {
      public void inorder(TreeNode node,List<Integer> list){
         if(node!=null){
              inorder(node.left,list);
              list.add(node.val);
              inorder(node.right,list);
         }
      }
  
      public boolean isSorted(List<Integer> list){
          for(int i=0;i<list.size()-1;i++){
              if(list.get(i)>=list.get(i+1))
                  return false;
          }
           return true;
      }
      public boolean isValidBST(TreeNode root) {
          if(root==null)
              return true;
          List<Integer> list=new ArrayList<>();
          inorder(root,list);
          return isSorted(list);
      }
  }
  

---