力扣【簡單級別】3

2019.9.20

175.組合兩個表（顫抖…第一次用Join）

SELECT FirstName, LastName, City, State 
FROM Person 
LEFT JOIN Address 
ON Person.PersonId = Address.PersonId

700.二叉搜索樹中的搜索（我終於會一點點樹的遞歸了！）

//遞歸
public TreeNode searchBST(TreeNode root, int val) {
    if(root == null){ return null;}
    if(root.val < val){
        return searchBST(root.right, val);
    }else if(root.val > val){
        return searchBST(root.left, val);
    }else{
        return root;
    }
}
//迭代
public TreeNode searchBST(TreeNode root, int val) {
    if(root == null){ return null;}
    TreeNode tmp = root;
    while(tmp != null){
        if(tmp.val == val){
            return root;
        }else if(tmp.val < val){
            root = root.right;
        }else if(root.val > val) {
            root = root.left;
        }
        tmp = root;
    }
    return null;
}

590.N叉樹的後序遍歷

//遞歸
private List<Integer> list = new ArrayList<Integer>();
public List<Integer> postorder(Node root) {
    post(root);
    return list;
}
private void post(Node root){
    if (root == null) {return;}
    for(Node node: root.children){
        post(node);
    }
    list.add(root.val);
}
//迭代
public List<Integer> postorder(Node root) {
        List<Integer> list = new ArrayList<>();
        Stack<Node> nodes = new Stack<>();
        if(root != null){
            nodes.push(root);
            while(!nodes.empty()){
                Node node = nodes.pop();
                list.add(node.val);
                for(Node n : node.children){
                    nodes.push(n);
                }
            }
            Collections.reverse(list);
        }
        return list;
    }

589.N叉樹的前序遍歷

//遞歸
private List<Integer> list1 = new ArrayList<Integer>();
    public List<Integer> preorder(Node root) {
        pre(root);
        return list1;
    }
    public void pre(Node root){
        if(root == null) return;
        list1.add(root.val);
        for(Node n : root.children){
            pre(n);
        }
    }
    //迭代
    public List<Integer> preorder(Node root) {
        List<Integer> lists = new ArrayList<>();
        Stack<Node> nodes = new Stack<>();
        if (root == null) return lists;
        nodes.push(root);
        while(!nodes.isEmpty()){
            Node node = nodes.pop();
            if(node != null) {
                lists.add(node.val);
                for (int i = node.children.size() - 1; i >= 0; i--) {
                    nodes.push(node.children.get(i));
                }
            }
        }
        return lists;
    }

2019.10.9

104.二叉樹的最大深度

    //深度優先遞歸
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        int l = maxDepth(root.left) + 1;
        int r = maxDepth(root.right) + 1;
        return l < r ?  r : l;
    }
    //深度優先迭代
    public int maxDepth1(TreeNode root) {
        int dep = 0;
        int max = 0;
        Stack<TreeNode> nodes = new Stack<>();
        Stack<Integer> deps = new Stack<>();
        while (!nodes.empty() || root != null) {
            //一直往左走
            while (root != null) {
                deps.push(++dep);
                nodes.push(root);
                root = root.left;
            }
            //右拐
            root = nodes.pop();
            dep = deps.pop();
            max = Math.max(max, dep);
            root = root.right;
        }
        return max;
    }

    public static void main(String[] arg){
        TreeNode node = new TreeNode(0 );
        node.left = new TreeNode(2);
        node.right = new TreeNode(4);
        node.left.left = new TreeNode(1);
        node.right.left = new TreeNode(3);
        node.right.right = new TreeNode(-1);
        node.left.left.left = new TreeNode(5);
        node.left.left.right = new TreeNode(1);
        node.right.left.right = new TreeNode(6);
        node.right.right.right = new TreeNode(8);
        System.out.println(maxDepth2(node));
    }

    //廣度優先迭代
    public static int maxDepth2(TreeNode root) {
        if(root == null) return 0;
        Queue<TreeNode> nodes = new LinkedList<>();
        nodes.offer(root);
        int dep = 0;
        while (!nodes.isEmpty()){
            dep++;
            int size = nodes.size();
            for(int i = 0; i < size; i++){
                TreeNode node = nodes.remove();
                if(node.left != null) nodes.offer(node.left);
                if(node.right != null) nodes.offer(node.right);
            }
        }
        return dep;
    }