LeetCode112-PathSum & LeetCode113-Path SumII(树的路径和问题)(递归和非递归)

版权声明:版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zxzxzx0119/article/details/83094503

LeetCode112-PathSum & LeetCode113-Path SumII(树的路径和问题)(递归和非递归)

  • LeetCode112递归
  • LeetCode112非递归
  • LeetCode113递归
  • LeetCode113非递归

LeetCode112题目链接

LeetCode112题目

在这里插入图片描述

LeetCode112递归

两种写法,从sum的角度去看,可以从sum减,也可以从0加到sum。
第一种:

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        
        if(root == null)
            return false;
        
        if(root.left == null && root.right == null)
            return root.val == sum;
        
        int newSum = sum - root.val;
        
        return hasPathSum(root.left,newSum) || hasPathSum(root.right,newSum);
    }
}

第二种:

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null)
            return false;
        return helper(root,0,sum);
    }
    
    private boolean helper(TreeNode node,int curSum,int sum){
        if(node == null)
            return false;
        if(node.left == null && node.right == null)
            return curSum + node.val == sum;
        curSum += node.val;        
        return helper(node.left,curSum,sum) || helper(node.right,curSum,sum);
    }
}

LeetCode112非递归

非递归,如果只使用一个栈(或者不使用辅助结构)的话,需要修改原来的树的结构:

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null)
            return false;
        Stack<TreeNode>stack = new Stack<>();
        stack.push(root);
        TreeNode cur = null;
        while(!stack.isEmpty()){
            cur = stack.pop();
            
            if(cur.left == null && cur.right == null && cur.val == sum)
                return true;
            
            if(cur.right != null){
                cur.right.val += cur.val;
                stack.push(cur.right);
            }  
             
            if(cur.left != null){
                cur.left.val += cur.val;
                stack.push(cur.left);
            }                
        }
        return false;
    }
}

写法可以有很多种,也可以使用一个栈存数,这样就不要改变树的结构:

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null)
            return false;
        Stack<TreeNode>nodeStack = new Stack<>();
        Stack<Integer>sumStack = new Stack<>();//存上到当前节点的数的值
        nodeStack.push(root);
        sumStack.push(sum);
        while(!nodeStack.isEmpty()){ 
            TreeNode curNode = nodeStack.pop(); 
            int curSum = sumStack.pop();

            if(curNode.left == null && curNode.right == null && curNode.val == curSum)
                return true;

            if(curNode.right != null){
                nodeStack.push(curNode.right);
                sumStack.push(curSum - curNode.val);
            }

            if(curNode.left != null){
                nodeStack.push(curNode.left);
                sumStack.push(curSum - curNode.val);
            }
        }
        return false;
    }
}

这里也可以使用类似BFS(层序)的遍历:
写法真的可以说是多种多样吧,层序使用队列即可,代码和BFS差别不大,但是我这里使用了另一个类,没有使用多余的两个队列,也保证没有修改树的结构。

class Solution {
    
    private class Comb{
        public int curSum;
        public TreeNode node;
        
        public Comb(TreeNode node,int curSum){
            this.node = node;
            this.curSum = curSum;
        }
    }
    
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null)
            return false;
        Queue<Comb>queue = new LinkedList<>();
        queue.add(new Comb(root,0)); //注意对应的关系
        
        while(!queue.isEmpty()){
            Comb cur = queue.poll();
            
            if(cur.node.left == null && cur.node.right == null && cur.curSum + cur.node.val == sum)
                return true;
            
            if(cur.node.left != null){
                queue.add(new Comb(cur.node.left,cur.curSum + cur.node.val));
            }
            
            if(cur.node.right != null){
                 queue.add(new Comb(cur.node.right,cur.curSum + cur.node.val));
            }
        }
        return false;
    }
}

LeetCode113题目链接

LeetCode11题目

在这里插入图片描述

LeetCode113递归

这题和上面唯一的不同,就是需要记录路径,递归写法很简单:

  • 就是每次先将当前节点加入中间集合(path),然后深度优先遍历;
  • 遍历完记得回溯的时候要在path集合中移除当前节点;
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>>res = new ArrayList<>();
        if(root == null)
            return res;
        helper(root,0,sum,new ArrayList<>(),res);
        return res;
    }
    
    private void helper(TreeNode node,int curSum,int sum,List<Integer>path,List<List<Integer>>res){
        if(node == null)
            return;
        path.add(node.val);
        if(node.left == null && node.right == null && curSum + node.val == sum){
            // why do we need new arraylist here?if we are using the same path variable path
            // path will be cleared after the traversal
            res.add(new ArrayList<>(path));
            // return ; // can't do this
        }
        helper(node.left,curSum+node.val,sum,path,res);
        helper(node.right,curSum+node.val,sum,path,res);
        path.remove(path.size()-1);
    }
}

LeetCode113非递归

非递归写法自己没有出来,看了讨论区,方法很好:

  • 当前节点cur只要不为空,先走到树的最左边节点(第一个while循环);
  • 然后取栈顶元素,但是此时还要继续判断栈顶的右孩子的左子树,此时不能pop(),因为有孩子还有可能也是有左子树的;
  • pre节点的作用是为了回溯,记录前一个访问的节点,如果cur.right == pre,则说明右子树正在回溯,下面的已经访问完了;
  • 实在不懂的可以画一个图看看。。。。
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>>res = new ArrayList<>();
        if(root == null)
            return res;
        
        Stack<TreeNode>stack = new Stack<>();
        ArrayList<Integer>path = new ArrayList<>();
        
        TreeNode cur = root,pre = null;
        int curSum = 0;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){  //先到最左边
                stack.push(cur);
                curSum += cur.val;
                path.add(cur.val);
                cur =cur.left;
            }
            cur = stack.peek(); //此时cur = 最左边的没有左孩子的节点
            
            //此时已经到了最左边,但是这个节点还是有可能有右孩子,且这个右孩子又有自己的左子树
            if(cur.right != null && cur.right != pre){ //有孩子不为空且没有被访问过
                cur = cur.right;
            }else { // 右孩子为空 或者 已经访问过 此时先判断是否叶子 然后 开始回溯
                if(cur.left == null && cur.right == null && curSum == sum)
                    res.add(new ArrayList<>(path));
                stack.pop();//出栈
                pre = cur; // 更新pre
                path.remove(path.size()-1);
                curSum -= cur.val;
                cur = null;//把当前的节点置为空,然后继续从栈中取别的节点
            }
        }
        return res;
    }
}

猜你喜欢

转载自blog.csdn.net/zxzxzx0119/article/details/83094503