2021-05-10算法打卡

17.剑指 Offer 34. 二叉树中和为某一值的路径

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

 

示例:
给定如下二叉树，以及目标和 target = 22，

               5
             /    \
            4     8
           /      /   \
         11   13    4
         /   \        /  \
       7    2      5    1
返回:

[
   [5,4,11,2],
   [5,8,4,5]
]
 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

从根节点开始直到叶子节点的路径，利用前序遍历，压栈的路径肯定是到达了叶子节点，且target为0；

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;

public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
            dfs(root, sum);
            return res;
    }
    //递归求解
    void dfs(TreeNode* curr, int target)
    {
        if(curr != nullptr){
            target -= curr->val;
            path.push_back(curr->val);
            if(target != 0 || curr->left != nullptr || curr->right != nullptr){
                dfs(curr->left, target);
                dfs(curr->right, target);
            }
            else{
                //满足结果且为根节点，将该路径压栈；
                res.push_back(path);
            }
            
            path.pop_back();
        }
    }
};

第一个解答可能有问题，但是提交通过了，因为没有考虑到target为负数的情况，负数也会压栈！

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;

public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
            dfs(root, sum);
            return res;
    }
    //递归求解
    void dfs(TreeNode* curr, int target)
    {
        if(curr != nullptr){
            target -= curr->val;
            path.push_back(curr->val);
            if(!target && !curr->left && !curr->right){
                //满足结果且为根节点，将该路径压栈；此处前判断条件，只能是target为0
                res.push_back(path);
            }
            else{
                dfs(curr->left, target);
                dfs(curr->right, target);
                
            }
            
            path.pop_back();
        }
    }
};

18.面试题 04.03. 特定深度节点链表

给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。

示例：

输入：[1,2,3,4,5,null,7,8]

        1
       /   \ 
      2    3
     /  \      \ 
    4   5     7
   /
  8

输出：[[1],[2,3],[4,5,7],[8]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/list-of-depth-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.利用队列实现二叉树的层序遍历；2.循环嵌套，内层循环将遍历每层的各个节点把其值保存到链表，提取完就出列当前节点，将该节点的左右孩子依次入列；3.重复第2步。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        //存储每个结果链表的头节点
        vector<ListNode*> res;
        //判断根节点是否为空
        if(tree == NULL){
            return res;
        }
        //用队列进行层序遍历
        queue<TreeNode*> q;
        q.push(tree);

        while(!q.empty()){
            ListNode* head = NULL;  //每次循环重新创建头节点
            ListNode* pre = NULL;

            //遍历当前层，同时将下一层的节点入列，并删除当前层的节点
            int currSize = q.size();
            for(int i = 0; i < currSize; i++){
                TreeNode* currNode = q.front(); //提取当前节点
                ListNode* newNode = new ListNode(currNode->val);  //创建新节点，保存树节点值，插入链表
                q.pop();  //提取完就出列
                
                //考虑链表首节点和构建
                if(head == nullptr){
                    head = newNode;
                }else{
                    pre->next = newNode;
                }
                pre = newNode;
                if(currNode->left != nullptr){
                    q.push(currNode->left);
                }
                if(currNode->right != nullptr){
                    q.push(currNode->right);
                }
            }
            res.push_back(head);
        }
        return res;
    }
};