leetcode 116,117,129,145,199,230,337

116 填充每个节点的下一个右侧节点

 　　这个题如果没有空间复杂度要求可以如下

    Map<Integer,Node> map;
    public  Node connect(Node root) {
        map = new HashMap<>();
        fill(root,1);
        return root;
    }

    public void fill(Node node,int level){
        if (node == null)return;
        Node cn = map.get(level);
        if (cn == null){
            map.put(level,node);
        }else {
            cn.next = node;
            map.put(level,node);
        }
        fill(node.left,level+1);
        fill(node.right,level+1);
    }

 　　如果是O1空间复杂度可以按照如下做

    public  Node connect(Node root) {
        fill(null,root,false);
        return root;
    }

    public void fill(Node pre,Node nod,boolean flag){
        if (nod == null)return;
        if (pre != null){
            if (flag){
                nod.next = pre.right;
            }else if (pre.next != null){
                nod.next = pre.next.left;
            }
        }
        pre = nod;
        fill(pre,nod.left,true);
        fill(pre,nod.right,false);
    }

117 填充每个节点的下一个右侧节点2

 　　汗，看了下这题的官方解我才知道之前解法陷入了误区，其实应该获取了某一层的next关系后，根据这层再拼接一下一层的next关系，和我上题的做法看着有些相似，但实际上是不一样的。

    Node node;
    Node current;
    public  Node connect(Node root) {
        node = root;
        while (node != null){
            current = null;
            Node e = node;
            while (e != null){
                handle(e.left);
                handle(e.right);
                e = e.next;
            }
            if (current == null)break ;
        }
        return root;
    }
    public void handle(Node n){
        if (n == null)return;
        if (current == null ){
            current = n;
            node = n;
        }else {
            current.next = n;
            current = current.next;
        }
    }

129 根节点到叶子节点数字之和 (汗 终于碰到了个简单的题)

class Solution {
 int total;
    public int sumNumbers(TreeNode root) {
        total = 0;
        int score = root.val;
         if (root.left == null && root.right == null){
            total = score;
         }else{
            cul(root.left,score);
            cul(root.right,score);
         }
       
        return total;
    }
    public void cul(TreeNode node,int score){
        if (node == null)return;
        int s = score*10+node.val;
        if (node.left == null && node.right == null){
            total += s;
        }else {
            cul(node.left,s);
            cul(node.right,s);
        }
    }
}

145  二叉树的前序遍历，简单题继续重拳出击 :)

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        LinkedList<TreeNode> stack = new LinkedList<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode pop = stack.pop();
            result.add(pop.val);
            if (pop.right != null){
                stack.push(pop.right);
            }
            if (pop.left != null){
                stack.push(pop.left);
            }
        }
        return result;
    }

146 二叉树的后序遍历 ，简单题继续重拳出击 :)

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null)return result;
        LinkedList<TreeNode> stack = new LinkedList<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode pop = stack.pop();
            TreeNode left = pop.left,right = pop.right;
            pop.left = pop.right = null;
             if(left != null || right != null){
                stack.push(pop);
                if (right != null){
                    stack.push(right);
                }
                if (left != null){
                    stack.push(left);
                }
             }else{
                result.add(pop.val);
             }         
        }
        return result;
    }
}

199  二叉树的右视图

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null)return result;
        List<TreeNode> list = new ArrayList<>();
        list.add(root);
        result.add(root.val);
        while (!list.isEmpty()){
            List<TreeNode> curren = new ArrayList<>();
            for (TreeNode treeNode : list) {
                if (treeNode.left != null)curren.add(treeNode.left);
                if (treeNode.right != null)curren.add(treeNode.right);
            }
            if (curren.isEmpty())break;
            result.add(curren.get(curren.size()-1).val);
            list = curren;
        }

        return result;
    }
}

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

    int k;
    int count;
    Integer result;
    public int kthSmallest(TreeNode root, int k) {
        count = 0;
        this.k = k;
        find(root);
        return result;
    }
    public void find(TreeNode root){
        if (result != null)return;
        if (root.left != null)find(root.left);
        if (++count == k){
            result=root.val;
            return;
        }
        if (root.right != null)find(root.right);

    }

337 打家劫舍问题|||

　　这个问题的系列共有三个，其实可以从简单的开始做，

　　第一个比较简单 是 数组内不连续的数据最大和  例如 [2,7,9,3,1]  最大的则为2+9+1 = 12

    public int rob(int[] nums) {
        if(nums.length == 0)return 0;
        if(nums.length == 1)return nums[0];
        if(nums.length == 2)return Math.max(nums[1],nums[0]);
        int[] dps = new int[nums.length];
        dps[0] = nums[0];
        dps[1] = Math.max(nums[1],nums[0]);
        for (int i = 2; i < nums.length; i++) {
            dps[i] = Math.max(dps[i-1],dps[i-2]+nums[i]);
        }
        return dps[nums.length-1];
    }

　　　第二个和第一个类似，只是首尾也算是连接的，所以可以当成两个数组  (0~n-1) (1-n) 分别求出最大的，最后求出最大的即可

public static int rob(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        if (nums.length == 1){
            return nums[1];
        }
        if (nums.length == 2){
            return Math.max(nums[0],nums[1]);
        }

        int[] dps1 = new int[nums.length-1];
        int[] dps2 = new int[nums.length-1];
        dps1[0] = nums[0];
        dps1[1] = Math.max(nums[1],nums[0]);

        dps2[0] = nums[1];
        dps2[1] = Math.max(nums[1],nums[2]);


        for (int i = 2; i < nums.length; i++) {
            if (i != nums.length-1){
                dps1[i] = Math.max(dps1[i-1],dps1[i-2]+nums[i]);
            }
            if (i != 2){
                dps2[i-1] = Math.max(dps2[i-2],dps2[i-3]+nums[i]);
            }
        }
        return Math.max(dps1[dps1.length-1],dps2[dps2.length-1]);
    }

　　有了前面两个再看本题，即是二叉树中如何求出所有非连接点之和的最大值,以为前面两个做了这个题应该很快能做好，结果怎么做都不对，难受。。。。。先放着