二叉树中某一值的路径之 先序遍历 + 二叉搜索树转化为循环双向链表 之 中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int target) {
        recur(root,target);
        return paths;
    }
private:
    vector<int>load;
    vector<vector<int>>paths;
    void recur(TreeNode* root,int target){
        if(root == nullptr) return;
        load.push_back(root->val);
        target -= root->val;
        if(target == 0 && root->left == nullptr && root->right == nullptr) paths.push_back(load);
        recur(root->left,target);
        recur(root->right,target);
        load.pop_back();
    }
};

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node* treeToDoublyList(Node* root) {
        if(root == nullptr)  return nullptr;
        dfs(root);
        head->left = pre;
        pre -> right = head;
        return head;
    }
private:
    Node* head,*pre;
    void dfs(Node* cur){
        if(cur == nullptr) return;
        dfs(cur->left);
        if(pre == nullptr) head = cur;
        else pre->right = cur;
        cur -> left = pre;
        pre = cur;
        dfs(cur -> right);
    }
};