DFS习题-LeetCode

Posted 2020-11-20 Lin.B

1、Path Sum

题目：

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

      5
     / \\
    4   8
   /   / \\
  11  13  4
 /  \\      \\
7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

分析：leetcode上一个关于DFS最简单的题目了，根据题意很容易用DFS来做，不过因为不知道树的大小，所以不能用visited数组来标识是否访问过。关键在于如何判断和为sum，第一个思路是用一个stack来保存访问过的root.val，回溯的过程就删掉最近的一个；第二个思路是每次递归都将问题化简为小子树，求和变成sum-root.val。

1 public boolean hasPathSum(TreeNode root, int sum) {
2         if ( root == null ) return false;
3         TreeNode t = root;
4         if ( t.left == null && t.right == null && sum - t.val == 0)  return true;
5        return hasPathSum(t.left, sum - t.val )|| hasPathSum(t.right, sum - t.val);
6 }

和同学讨论了一下，我刚开始想的是判断左子树是否为null，不为null就递归左子树，然后再判断右子树，但是发现这样无法确定最后的return语句了。因此在做递归/DFS问题时，关于true或者false的判断一定要在最前面做，后面只是单纯的做函数的循环！这个是DFS代码的技巧，希望一定要记住。

---

 

2、Same Tree

题目：

Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1:

Input:     1         1
          / \\       / \\
         2   3     2   3

        [1,2,3],   [1,2,3]

Output: true

Example 2:

Input:     1         1
          /           \\
         2             2

        [1,2],     [1,null,2]

Output: false

Example 3:

Input:     1         1
          / \\       / \\
         2   1     1   2

        [1,2,1],   [1,1,2]

Output: false

分析：这个题是要求我们判断两个数是否完全相等，当然可以从两个角度来做，一个是BFS，一个是DFS。

BFS的话，就是遍历每一层，使用非递归的方法，大体思路要用Queue来实现，具体代码如下：

 1     public boolean isSameTree(TreeNode p, TreeNode q) {
 2 
 3         //BFS版本，用非递归实现。代码量比较冗长
 4         Queue<TreeNode> queue1 = new LinkedList<>();
 5         Queue<TreeNode> queue2 = new LinkedList<>();
 6 
 7         if ( p == null && q == null ) return true;
 8         if ( p == null || q == null ) return false;
 9         queue1.offer(p);
10         queue2.offer(q);
11 
12         while ( queue1.size() > 0 && queue2.size() > 0 ){
13             TreeNode t1 = queue1.poll();
14             TreeNode t2 = queue2.poll();
15             if ( t1.val != t2.val ) return false;
16             if ( t1.left != null && t2.left != null ){
17                 queue1.offer(t1.left);
18                 queue2.offer(t2.left);
19             }
20             if ( t1.left == null && t2.left != null ) return false;
21             if ( t1.left != null && t2.left == null ) return false;
22 
23             if ( t1.right != null && t2.right != null ){
24                 queue1.offer(t1.right);
25                 queue2.offer(t2.right);
26             }
27             if ( t1.right == null && t2.right != null ) return false;
28             if ( t1.right != null && t2.right == null ) return false;
29         }
30         return true;
31 }

可以看到用BFS出现了大量的代码重用，多余空间，效率确实不高，在leetcode上运行需要6ms，主要问题就是不简洁，可读性不高

那么用DFS来实现就简单的多，因为使用递归，所以代码很简洁。DFS使用一定要注意只关注当前状态而不去考虑之前或者之后的状态。这个理论在判断递归结束条件的时候非常有用。在本题中，判断true的条件就是搜索到叶子节点，代码如下：

1 public boolean isSameTree(TreeNode p, TreeNode q) {
2     if ( p == null && q == null ) return true;
3     if ( p == null || q == null ) return false;
4     if ( p.val != q.val ) return false;
5     return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
6 }

注意，这里return true并不是返回最后的结果，只是返回当前状态对应的状态结果。

---

 

3、Minmum Depth of Binary Tree

题目：

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

    3
   / \\
  9  20
    /  \\
   15   7

return its minimum depth = 2.

分析：求二叉树的最小高度，显然用DFS来做。分析过程如下：

这里理解了一下递归的思想，递归是将大问题不断转化成小的问题，关键是找到递归结束条件和递归时机。代码如下：

 1     public int minDepth(TreeNode root) {
 2         if ( root == null ) return 0;
 3         return DFS(root);
 4     }
 5     public int DFS(TreeNode root) {
 6         if ( root.left == null && root.right == null ) return 1;   //找到一个叶子节点，那么叶子节点就是1层
 7         if ( root.left == null ) {
 8             return DFS(root.right) + 1;
 9         }
10         if ( root.right == null ) {
11             return DFS(root.left) + 1;
12         }
13         return Math.min(DFS(root.left), DFS(root.right)) + 1;
14     }