二叉树 103. 二叉树的锯齿形层序遍历 230. 二叉搜索树中第K小的元素

题目：给你二叉树的根节点 root ，返回其节点值的锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
在Java中，没有直接内置的“双端队列”（Deque）的概念，但是我们可以使用LinkedList类来实现一个双端队列，因为LinkedList实现了Deque接口
使用层序遍历加双端链表的方式

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if (root != null) queue.add(root);
        while (!queue.isEmpty()) {
            LinkedList<Integer> tmp = new LinkedList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if (res.size() % 2 == 0) tmp.addLast(node.val);
                else tmp.addFirst(node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

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

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

class Solution {
    //左根右遍历到第k个
    public int kthSmallest(TreeNode root, int k) {
        Stack<TreeNode> nodeStack=new Stack<>();
        nodeStack.push(root);
        while(!nodeStack.isEmpty()){
            TreeNode tmp=nodeStack.peek();
            if(tmp==null){
                nodeStack.pop();
                k--;
                if(k==0){
                    return nodeStack.peek().val;
                }
                nodeStack.pop();
            }else{
                nodeStack.pop();
                if(tmp.right!=null){
                    nodeStack.push(tmp.right);
                }
                nodeStack.push(tmp);
                nodeStack.push(null);
                if(tmp.left!=null){
                    nodeStack.push(tmp.left);
                }
            }

        }
        return -1;
    }
}

如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化算法？
我们可以记录下以每个结点为根结点的子树的结点数，并在查找第 kkk 小的值时，使用如下方法搜索：
令 node等于根结点，开始搜索。
对当前结点 node进行如下操作：
如果 node 的左子树的结点数 left小于 k−1，则第 k 小的元素一定在 node\的右子树中，令 node等于其的右子结点，k 等于 k−left−1，并继续搜索；
如果 node 的左子树的结点数 left等于 k−1，则第 k小的元素即为 node，结束搜索并返回 node 即可；
如果 node 的左子树的结点数 left大于 k−1，则第 k小的元素一定在 node 的左子树中，令 node等于其左子结点，并继续搜索。

class Solution {
    public int kthSmallest(TreeNode root, int k) {
        MyBst bst = new MyBst(root);
        return bst.kthSmallest(k);
    }
}

class MyBst {
    TreeNode root;
    Map<TreeNode, Integer> nodeNum;

    public MyBst(TreeNode root) {
        this.root = root;
        this.nodeNum = new HashMap<TreeNode, Integer>();
        countNodeNum(root);
    }

    // 返回二叉搜索树中第k小的元素
    public int kthSmallest(int k) {
        TreeNode node = root;
        while (node != null) {
            int left = getNodeNum(node.left);
            if (left < k - 1) {
                node = node.right;
                k -= left + 1;
            } else if (left == k - 1) {
                break;
            } else {
                node = node.left;
            }
        }
        return node.val;
    }

    // 统计以node为根结点的子树的结点数
    private int countNodeNum(TreeNode node) {
        if (node == null) {
            return 0;
        }
        nodeNum.put(node, 1 + countNodeNum(node.left) + countNodeNum(node.right));
        return nodeNum.get(node);
    }

    // 获取以node为根结点的子树的结点数
    private int getNodeNum(TreeNode node) {
        return nodeNum.getOrDefault(node, 0);
    }
}