leetcode树有关题目随笔

2019/11/22

109题 没想到用两个指针好在可以自己想出点东西但是是错的错误如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        int len = 1;
        ListNode cur = head; 
        while(cur.next!=null){
            len +=1;
            cur=cur.next;
        }
        return sortedListToBST(head,0,len);
    }
    private TreeNode sortedListToBST(ListNode head,int start,int end){
        int mid=(start+end)>>>1;
        ListNode cur = head;
        int i=mid;
        while(i>0){
            cur=cur.next;
            i--;
        }
        TreeNode root = new TreeNode(cur.val);
        root.left=sortedListToBST(head,start,mid-1);
        root.right=sortedListToBST(cur,mid+1,end);
        return root;
    }
}

View Code

注意体会官方解法方法 3：中序遍历模拟用到的思想。

1做过数组还原平衡二叉搜索树（推荐先做题号108），我们知道，在array中每次取中点作为根节点，左右分别构建左右子树，递归直至根节点为空。
2链表的特性导致我们无法像数组那样通过下标访问各个元素。若想按照108题的做法，就需要设置两个指针p1 p2，p1每走一步p2走两步，这样p2结束时p1就在中点。但这样会导致每次递归都需要重复遍历链表，效率较低。
3我们考虑是否可以让建立节点的顺序匹配链表元素顺序？这样每次建立节点时，只需要获取链表下一个元素即可。
4使用递归模拟中序遍历过程，建立节点的顺序即与链表元素顺序一一对应，bottom-up建立树，最终返回根节点。
5递归前需要统计链表长度n，整体算法复杂度O(N)。

===========================================

后序遍历的代码

public void PrintBinaryTreeBacRecur(TreeNode<T> root){
    if (root == null)
        return;
    
    PrintBinaryTreeBacRecur(root.right);
    PrintBinaryTreeBacRecur(root.left); 
    System.out.print(root.data);
    
}

先序遍历迭代

public static void preOrderStack(TreeNode root) {
    if (root == null) { 
        return;
    }
    Stack<TreeNode> s = new Stack<TreeNode>();
    while (root != null || !s.isEmpty()) {
        while (root != null) {
            System.out.println(root.val);
            s.push(root);
            root = root.left;
        }
        root = s.pop();
        root = root.right;
    }
}

还有一种特殊的先序遍历，提前将右孩子保存到栈中，我们利用这种遍历方式就可以防止右孩子的丢失了。由于栈是先进后出，所以我们先将右节点入栈。

public static void preOrderStack(TreeNode root) {
    if (root == null){
        return;
    }
    Stack<TreeNode> s = new Stack<TreeNode>();
    s.push(root);
    while (!s.isEmpty()) {
        TreeNode temp = s.pop();
        System.out.println(temp.val);
        if (temp.right != null){
            s.push(temp.right);
        }
        if (temp.left != null){
            s.push(temp.left);
        }
    }
}

作者：windliang
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--26/
来源：力扣（LeetCode）

==============================================

113题路径总和||

作者：powcai
链接：https://leetcode-cn.com/problems/path-sum-ii/solution/dfs-by-powcai-2/
来源：力扣（LeetCode）

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> res = new ArrayList<>();
        helper(root, sum, res, new ArrayList<Integer>());
        return res;
    }

    private void helper(TreeNode root, int sum, List<List<Integer>> res, ArrayList<Integer> tmp) {
        if (root == null) return;
        tmp.add(root.val);
        if (root.left == null && root.right == null && sum - root.val == 0) res.add(new ArrayList<>(tmp));
        helper(root.left, sum - root.val, res, tmp);
        helper(root.right, sum - root.val, res, tmp);
        tmp.remove(tmp.size() - 1);
    }
}

仿照答案中更快的写法在helper中加了一个返回结果更快

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
       List<List<Integer>> res = new ArrayList<>();
       helper(root,sum,res,new ArrayList<Integer>());
       return res;
    }
    public void helper(TreeNode root,int sum,List<List<Integer>> res, ArrayList<Integer> tmp){
        if(root==null) return;
        tmp.add(root.val);
        if(root.left==null&&root.right==null&&sum-root.val==0) {
            res.add(new ArrayList<>(tmp));
            tmp.remove(tmp.size()-1);
            return;
        }
        helper(root.left,sum-root.val,res,tmp);
        helper(root.right, sum - root.val, res, tmp);
        tmp.remove(tmp.size() - 1);
    }


}

94. 二叉树的中序遍历 2020/1/7

二叉树的前序中序后序遍历还需要巩固巩固一开始想到了递归的方法，但是没想出来代码

递归方法（基本方法）、迭代方法（迭代就是使用栈来做，这个思想好好学习学习）

96. 不同的二叉搜索树 2020/1/7

遍历每个数字 i，将该数字作为树根，1 ... (i-1) 序列将成为左子树，(i+1) ... n 序列将成为右子树这个想法必修得有

笛卡尔积由于

98. 验证二叉搜索树 2020/1/7

一般的迭代方法肯定要会把类似于94题用栈迭代

中序遍历牛那个方法要掌握并能想起来按照12345在前序中序后序中的遍历顺序来检验

最大值最小值的方法真的绝了

100. 相同的树 2020/1/8

这里有一个大佬给的关于树的解题模板

void BST(TreeNode root, int target) {
    if (root.val == target)
        // 找到目标，做点什么
    if (root.val < target) 
        BST(root.right, target);
    if (root.val > target)
        BST(root.left, target);
}