199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

/**
 * 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<Integer> rightSideView(TreeNode root) {
        List<Integer> a=new ArrayList<Integer>();
        Deque<TreeNode> tree=new LinkedList<TreeNode>();
        if(root!=null)
            tree.push(root);
        while(!tree.isEmpty())
        {
            a.add(tree.peekFirst().val);
            int c=tree.size();
            while(c>0)
            {
                if(tree.peekLast().left!=null)
                    tree.push(tree.peekLast().left);
                if(tree.peekLast().right!=null)
                    tree.push(tree.peekLast().right);
                tree.removeLast();
                c--;
            }
        }
        return a;
    }
}

个人总结： 解决问题的方法没想到，就时层级遍历，存入最右边的数。

113. 路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

/**
 * 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 {
    List<List<Integer>> w=new ArrayList<List<Integer>>();
    Deque<Integer> path=new LinkedList<Integer>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        Deque<Integer> path=new LinkedList<Integer>();
        p(root,targetSum);
        return w;
    }
    public void p(TreeNode root, int targetSum) {
        if(root==null)
            return;
        path.addLast(root.val);
        targetSum=targetSum-root.val;
        if(root.left==null&&root.right==null&&targetSum==0)
        {
            w.add(new LinkedList<Integer>(path));
            
        }
        
        p(root.left,targetSum);
        p(root.right,targetSum);
        path.removeLast();        
    }
}

个人总结： 当要注意确定节点时，用堆栈暂时存储前面的数据。

450. 删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。

说明： 要求算法时间复杂度为 O(h)，h 为树的高度。

示例:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / \
  3   6
 / \   \
2   4   7

给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

    5
   / \
  4   6
 /     \
2       7

另一个正确答案是 [5,2,6,null,4,null,7]。

    5
   / \
  2   6
   \   \
    4   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 int la(TreeNode root)
    {
        if(root.left==null)
            return root.val;
        return la(root.left);
    }
    public int pre(TreeNode root)
    {
        if(root.right==null)
            return root.val;
        return la(root.right);
    }
    public TreeNode deleteNode(TreeNode root, int key) {
        if(root==null)
            return null;
        if(key>root.val)
            root.right=deleteNode(root.right,key);
        if(key<root.val)
            root.left=deleteNode(root.left,key);
        if(key==root.val)
        {
            if(root.left==null&&root.right==null)
                root=null;
            else if(root.right!=null)
            {
                root.val=la(root.right);
                root.right=deleteNode(root.right,root.val);
            }else{
                root.val=pre(root.left);
                root.left=deleteNode(root.left,root.val);
            }
        }
        return root;
    }
}

个人总结： 不太会，拓展了思路，更加了解对二叉搜索树的操作。