二叉樹與遞歸

二叉樹與遞歸

• 求一個二叉樹的最深高度（從根節點到某一個葉子節點的最長路徑的長度）

  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);
      }
  }
  

---