leetcode二叉树问题合集

/*
 * 515.需要层次遍历二叉树，再找出每层的最大值
 * 513. 找树的最底层最左边的值        Find Bottom Left Tree Value
 * 501. Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.
 *   Find Mode in Binary Search Tree
 * 102. Binary Tree Level Order Traversal 二叉树的一层
 * 129. 找出所有头结点到叶子结点的路径，添加所有的和
 */
public class treelargestValue {
 
   public class TreeNode {
       int val;
       TreeNode left;
       TreeNode right;
       TreeNode(int x) { val = x; }
   }
   //原始的层次遍历
   /*
   public List<Integer> largestValues(TreeNode root) {//队列
    Queue<TreeNode> queue=new LinkedList<TreeNode>();//重点 要会写这个new语句
    if(root !=null){
     queue.add(root);
    }
    while(queue.isEmpty()==false){
     TreeNode node=queue.poll();//删除并返回队头元素
     System.out.println(node.val);//此处打印node的值
     if(node.left!=null) queue.add(node.left);//左孩子进队
     if(node.right!=null) queue.add(node.right);//右孩子进队
    }
    queue.clear();
   }
   */
   ////原始的深度优先遍历---即前序遍历非递归
   /*
     public int sumNumbers(TreeNode root) {
         Stack<TreeNode> st=new Stack<TreeNode>();//栈
         if(root==null){
          return 0;
         }
         st.add(root);
         int res=0;
         while(st.isEmpty()==false){          
          TreeNode node=st.peek();
          System.out.println(node.val);
             st.pop();
             if(node.right!=null) st.push(node.right);//注意先右后左
             if(node.left!=null)  st.push(node.left);
         }
         return res;
     }
 
    */
  
  
  
   //////////////515.需要层次遍历二叉树，再找出每层的最大值
   public List<Integer> largestValues(TreeNode root) {
          Queue<TreeNode> queue=new LinkedList<TreeNode>();//队列初始化语句！重点 要会写这个new语句
    List<Integer> results=new ArrayList<Integer>();//List初始化语句！
     if(root !=null){
      queue.add(root);
     }
     while(queue.isEmpty()==false){
      int size=queue.size();
      int maxZ=Integer.MIN_VALUE;//注意：此处不能初始化int maxZ=0；因为存在负数。
      for(int i=0;i<size;i++){
       TreeNode node=queue.poll();//删除并返回队头元素
       //System.out.println(node.val);
       if(maxZ<node.val) maxZ=node.val; //此处设置选择最大值的标识，重点！！！     
       if(node.left!=null) queue.add(node.left);//左孩子进队
       if(node.right!=null) queue.add(node.right);//右孩子进队
      
      }
      results.add(maxZ);
     }
     queue.clear();
     return results;
     }
  
   ///////////////////513. 找树的最底层最左边的值        Find Bottom Left Tree Value
     public int findBottomLeftValue(TreeNode root) {
      Queue<TreeNode> queue=new LinkedList<TreeNode>();
      List<Integer> A=new LinkedList<Integer>();
      if(root !=null){
       queue.add(root);
      }
      while(queue.isEmpty()==false){
       int size=queue.size();
       int B[]=new int [1000];//注意初始化数组,intB[]是声明,new int[1000]是分配存储空间
       for(int i=0;i<size;i++){                
        TreeNode node=queue.poll();//返回并删除栈顶;
        //System.out.println(node.val);
        if(node.left !=null) queue.add(node.left);
        if(node.right !=null) queue.add(node.right);
        B[i]=node.val;
        A.add(B[0]);
        //A.add(node.val);
        //int result=A.get(0);
       }
       
      }
      int result=A.get(A.size()-1);
      queue.clear(); 
   return result;
        
     }
    /* ////////////501
     //先中序遍历BST有序二叉查找树
     public List<Integer> Intree(TreeNode root) {
        List<Integer> results=new LinkedList<Integer>();
        if(root==null){
         return results;
        }
        if(root.left!=null){
         List<Integer> res=new LinkedList<Integer>();
         res=Intree(root.left);
         results.addAll(res);
        }
        results.add(root.val);
        if(root.right!=null){
         List<Integer> res=new LinkedList<Integer>();
         res=Intree(root.right);
         results.addAll(res);
        }
        return results;
     }
   
     public int[] findMode(TreeNode root) {
        int a[]=new int [1000];
       int maxkey=0;
       int maxvalue=0;
        List<Integer> A=new LinkedList<Integer>();
        A=Intree(root); 
        HashMap<Integer,Integer> hashMap=new HashMap<Integer,Integer>();
        for(int i=0;i<A.size();i++){
         if(A.get(i)==A.get(i+1)){
         maxkey++;
         maxvalue=A.get(i);
         }else{
          hashMap.put(maxvalue,maxkey);
          maxkey=0;
          maxvalue=0;
         }
        }
   

        Iterator it = A.iterator(); //迭代遍历List
        while(it.hasNext()) {      
          System.out.println(it.next());
        }       
      
       
     }
  
  
 3月2日晚备份
  * public List<Integer> Intree(TreeNode root) {
        List<Integer> results=new LinkedList<Integer>();
        if(root==null){
         return results;
        }
        if(root.left!=null){
         List<Integer> res=new LinkedList<Integer>();
         res=Intree(root.left);
         results.addAll(res);
        }
        results.add(root.val);
        if(root.right!=null){
         List<Integer> res=new LinkedList<Integer>();
         res=Intree(root.right);
         results.addAll(res);
        }
        return results;
     }
     public int[] findMode(TreeNode root) {
        List<Integer> A=new LinkedList<Integer>();
        A=Intree(root);
        Iterator it = A.iterator();
        while(it.hasNext()) {
          System.out.println(it.next());
        }
        int a[]=new int [100];
        return a;        
       
     } 
 
  
   */
 //102.还是层次遍历，没什么问题 
    public List<List<Integer>> levelOrder(TreeNode root) {
     List<List<Integer>> res=new ArrayList<List<Integer>>();
     Queue<TreeNode> queue=new LinkedList<TreeNode>();
     if(root==null){
      return res;
     }
     queue.add(root);
     while(queue.isEmpty()==false){
      int size=queue.size();
      List<Integer> temp=new ArrayList<Integer>();
      for(int i=0;i<size;i++){     
          TreeNode root2=queue.poll();
          temp.add(root2.val);
          if(root2.left!=null) queue.add(root2.left);
          if(root2.right!=null) queue.add(root2.right);
         
      }
      res.add(new ArrayList<Integer>(temp));      
     }
      return res;
    }
 
    //129. Sum Root to Leaf Numbers （深度优先----栈）
    // 找出所有头结点到叶子结点的路径，添加所有的和  
    public int sumNumbers(TreeNode root) {
        Stack<TreeNode> st=new Stack<TreeNode>();
        if(root==null){
         return 0;
        }
        st.add(root);
        int res=0;
        while(st.isEmpty()==false){
         int temp=0;

      TreeNode node=st.peek();
      System.out.println(node.val);
         st.pop();
         temp=node.val+temp*10;
         if(node.left==null && node.right==null){
          res=res+temp;
          temp=temp/10;//错的！！！
         }
         if(node.right!=null) st.push(node.right);//注意先右后左
         if(node.left!=null)  st.push(node.left);
                
        }
        return res;
    }
    //正确的非递归方法。思路是建立一个新栈，用来储存值。
    public int sumNumbersR(TreeNode root)
 {
  Stack<TreeNode> stack = new Stack<TreeNode>();
  Stack<Integer> stack1 = new Stack<Integer>();
  stack.add(root);
  stack1.add(0);
  int res = 0;
  while (!stack.isEmpty())
  {
   root = stack.pop();
   int val = stack1.pop();
   if (root != null)
   {
    val = val * 10 + root.val;
    if (root.left == null && root.right == null) res += val;
    stack.add(root.left);
    stack1.add(val);
    stack.add(root.right);
    stack1.add(val);
   }
  }
  return res;
 }
    /*//原始先序列遍历（深度优先）
     *  public int sumNumbers(TreeNode root) { 
     if(root!=null){
   System.out.println(root.val);
   sumNumbers(root.left);
   sumNumbers(root.right);
  } 
  return 0;
 }
   
     */
    //2、递归法
    private int res=0;
    private int num=0;// 记根到叶子的数字
    public int sumNumbers2(TreeNode root) { 
     sum(root);
     return res;
    }

 private void sum(TreeNode root) {
  if(root!=null){
   num=num*10+root.val;
   if(root.left==null && root.right==null){//已经到根结点
    res=res+num;
   }
   sum(root.left);
   sum(root.right);
   num=num/10;  //除10取整
  } 
 }
  
  
  
  
  
  
  
  
  

}