leetcode—二叉树进阶

1 二叉树的层序遍历

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

示例 1：

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

方法一

思路：队列

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        // 创建列表 用于返回最终结果
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        // 若根节点为空 返回列表
        if(root == null){
            return result;
        }

        // 创建队列 用于层序遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        // 将根节点入队
        queue.offer(root);

        // 若队列不为空  开始层序遍历
        while(!queue.isEmpty()){
            // 新建列表  存放当前层节点的值
            List<Integer> level = new ArrayList<Integer>();
            // 当前队列的长度
            int currentLevelSize = queue.size();
            // 遍历当前层
            for(int i = 0; i < currentLevelSize; i++){
                // 出队 并将出队的节点的值存放在level列表中
                TreeNode node = queue.poll();
                level.add(node.val);

                // 左子树入队
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 右子树入队
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            result.add(level);
        }
        return result;
    }
}

方法二 

思路：递归

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        levelOrderHelper(root, list ,0);
        return list;
        
    }
    // 二叉树的层序遍历 递归
    public void levelOrderHelper(TreeNode root, List<List<Integer>> list, int level){
        if(root == null){
            return ;
        }
        // 如果当前层的列表不存在 创建一个新的列表
       if(level >= list.size()) {
			list.add(new ArrayList<>());
		}
        // 将当前层的节点值添加到当前层的列表中
		list.get(level).add(root.val);
        
		levelOrderHelper(root.left,list,level+1);
		levelOrderHelper(root.right,list,level+1);

    }

}

2 验证二叉搜索树

示例 1：

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

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

二叉树的中序遍历是升序序列

class Solution {
    public boolean isValidBST(TreeNode root) {
        long lower = Long.MIN_VALUE;
        long upper = Long.MAX_VALUE;
        return isValidBSTHelp(root,lower,upper);

    }
    /*
    辅助递归函数  参数依次为二叉树，下界  上界（这两值初始化时为最小值 最大值）
    当判断左子树是否为二叉搜索树时:  边界为(lower, node.val)
    当判断右子树是否为二叉搜索树时:  边界为(node.val, upper)
    */
    public boolean isValidBSTHelp(TreeNode node, long lower, long upper){
        // 若二叉树为空 为搜索二叉树
        if(node == null){
            return true;
        }
        // 若当前节点不在边界范围内 则不是 二叉搜索树
        if(node.val <= lower || node.val >= upper){
            return false;
        }

        // 递归遍历左右子树
        boolean isLeftBST = isValidBSTHelp(node.left,lower, node.val);
        boolean isRightBST = isValidBSTHelp(node.right, node.val, upper);

        return isLeftBST && isRightBST;

    }
}

3 二叉搜索树中的第K小的元素

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

示例 1：

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

方法一

思路：栈

class Solution {
    public int kthSmallest(TreeNode root, int k) {
        // 创建栈用于二叉搜索树的中序遍历
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        // 当节点不为空 或者 栈不为空时 开始循环
        while(root != null || ! stack.isEmpty()){
            while(root != null){
                stack.push(root);   // 当前节点入栈
                root = root.left;
            }
            // 栈顶元素出栈
            root = stack.pop();
            k --;
            // 当计数减为0时，说明找到第K小节点 返回其值
            if(k == 0){
                break;
            }
            root = root.right;
        }
        return root.val;
    }

方法二

思路：递归（中序遍历）

class Solution {
    int result;
    // 用于判断是否访问到第K个元素
    // 注意 必须将tag设置为全局变量  若放在递归函数中 每次递归都重新实例化
    int tag = 1;
    public int kthSmallest(TreeNode root, int k) {
        // 查找第K小的元素 可以转换为 求二叉搜索树中序遍历的第K个元素
        inOrder(root,k);
        return result;
      
    }
    public void inOrder(TreeNode root, int k){
        if(root == null){
            return ;
        } 
        inOrder(root.left,k);
        // 若找到第K个元素 直接返回当前节点的值
        if(tag == k){
            result =  root.val;
        }
        tag ++;
        inOrder(root.right, k);
      
    }
}