树型算法题解

树结构如下

 public class TreeNode {
   
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode(int x) {
    val = x; }
  }

1. 获取给定二叉树最小深度

思路：通过广度优先遍历能更快找到最优解。深度优先搜索也可以找到最优解，但是需要找到所有解后

广度优先搜索,一层一层搜索，搜索到某个节点左右节点都为空，则为叶子结点。缺点是相对比较占空间，需要用一个队列记录下一次要搜索的节点。每层搜索完层数+1。

import java.util.LinkedList;
public class Solution {
     
    public int run(TreeNode root) {
   
         if (root == null) {
   
            return 0;
        }
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        int level = 1,start = 0,end=1;
        while (!queue.isEmpty()) {
   
            TreeNode temp = queue.remove();
            start ++;
            if (temp.left == null && temp.right == null) {
   
                return level;
            }
            if (temp.left != null) {
   
                queue.add(temp.left);
            }
            if (temp.right != null) {
   
                queue.add(temp.right);
            }
            if (start == end){
   
                start = 0;
                end = queue.size();
                level ++;
            }
        }
        return level;
    }
}

深度优先搜索，搜索每个路径的深度，通过比较获得最小路径。通过递归或栈实现。需要注意一个特殊的情况，如果某个节点只有左节点或者只有右节点，应该统计有节点的那条路径，没有节点的那路径相当于没有叶子节点，不能用那个路径统计。

public class Solution {
   
    public int run(TreeNode root) {
   
        if (root == null) {
   
            return 0;
        }        
        if (root.left == null && root.right == null) {
   
            return 1;
        }
        int leftDept = run(root.left);
        int rightDept = run(root.right);
        if (leftDept == 0 || rightDept == 0){
   
            return leftDept + rightDept + 1;
        }
        return leftDept < rightDept? leftDept+1 : rightDept+1; 
    }
}

2. 获取给定二叉树的后序遍历

思路：通过递归或栈实现。

递归,递归到左子树最深处。从底往上搜，先搜左子树，再搜右子树，再把当前节点加入集合。

public class Solution {
   
    ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
   
        if (root == null){
   
            return list;
        }
        if (root.left == null && root.right == null){
   
            list.add(root.val);
            return list;
        }
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
    
}

栈实现，可以通过Stack实现。

1. 先加入跟节点，根据跟节点遍历子节点，因为是后序遍历，所以父节点先不出栈，通过peek方法获取栈顶，但是不出栈
2. 先让右节点进栈，因为左节点要先出栈。
3. 暂存上一个出栈的节点，判断如果上一个节点是当前节点的子节点，即可出栈。因为子节点都是后进栈的，所以判断是任意一个子节点出栈，都代表当前可以出栈了（考虑有可能某个方向的节点为空，不然直接判断上一节点为右节点就好了）。
4. 如果没有子节点也可以直接出栈了。

public class Solution {
   
    ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
   
        if (root == null){
   
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);    
        TreeNode preNode = null;
        while (!stack.empty()){
   
            TreeNode node = stack.peek();
            if ((node.left == null && node.right == null)||
                ( preNode !=null && (preNode == node.left || preNode == node.right))){
   
                list.add(node.val);
                stack.pop();
                preNode = node;
            }else{
   
                if (node.right !=null){
   
                    stack.push(node.right);
                }
                if (node.left !=null){
   
                    stack.push(node.left);
                }
            }         
        }
        return list;
    } 
}

3. 获取给定二叉树的先序遍历

思路： 通过递归或栈实现。

通过递归实现，先将当前节点加入集合，再搜索左子树，再搜索右子树。

public class Solution {
   
    ArrayList<Integer> list =  new ArrayList<>();
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
   
        if (root == null){
   
            return list;
        }
        list.add(root.val);
        if (root.left == null && root.right == null){
   
            return list;
        }
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return list;
    }
}

通过栈实现,先入栈根节点，出栈后加入集合，再入栈右节点，再入栈左节点。根据后进先出，左节点会先搜索。

public class Solution {
   
    ArrayList<Integer> list =  new ArrayList<>();
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
   
        if (root == null){
   
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()){
   
            TreeNode node = stack.pop();
            list.add(node.val);
            if (node.right != null){
   
               stack.push(node.right);
            }
            if (node.left != null){
   
               stack.push(node.left);
            }   
        }
        return list;
    }
}

<