二叉树和图

Leetcode113深度搜索-路径之和

 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        std::vector<std::vector<int>>result;
        std::vector<int>path;
        int path_value=0;
        preorder(root,path_value,sum,path,result);
        return result;
    }
private:
    void preorder(TreeNode *node,int &path_value,int sum,std::vector<int>&path,
                 std::vector<std::vector<int>>&result){
        if(!node)return;
        path_value+=node->val;
        path.push_back(node->val);
        if(!node->left&&!node->right&&sum==path_value){
            result.push_back(path);
        }
        preorder(node->left,path_value,sum,path,result);
        preorder(node->right,path_value,sum,path,result);
        path_value-=node->val;
        path.pop_back();
    }
};

Leetcode236 最近的公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        std::vector<TreeNode* >path;
        std::vector<TreeNode* >node_p_path;
        std::vector<TreeNode* >node_q_path;
        int finish=0;
        preorder(root,p,path,node_p_path,finish);
        path.clear();
        finish=0;
        preorder(root,q,path,node_q_path,finish);
        int path_len=0;
        if(node_q_path.size()<node_p_path.size()){
            path_len=node_q_path.size();
        }
        else{
            path_len=node_p_path.size();
        }
        TreeNode *result=0;
        for(int i=0;i<path_len;i++){
            if(node_q_path[i]==node_p_path[i]){
                result=node_p_path[i];
            }

        }
        return result;

    }
private:
    void preorder(TreeNode* node,TreeNode *search,
                  std::vector<TreeNode*>&path,
                  std::vector<TreeNode*>&result,
                  int &finish){
        if(!node||finish){
            return;
        }
        path.push_back(node);
        if(node==search){
            finish=1;
            result=path;
        }
        preorder(node->left,search,path,result,finish);
        preorder(node->right,search,path,result,finish);
        path.pop_back();
    }        
        
};

Leetcode 114二叉树转链表

• 方法一（不就地）

class Solution {
public:
    void flatten(TreeNode* root) {
         std::vector<TreeNode*>node_vec;
        preorder(root,node_vec);
        for(int i=1;i<node_vec.size();i++){
            node_vec[i-1]->right=node_vec[i];
            node_vec[i-1]->left=NULL;
        }
    }
private:
    void preorder(TreeNode *node,std::vector<TreeNode*>node_vec){
        if(!node)return;
        node_vec.push_back(node);
        preorder(node->left,node_vec);
        preorder(node->right,node_vec);
    }
};

• 方法二（就地）递归

class Solution {
public:
    void flatten(TreeNode* root) {
        TreeNode* last=NULL;
        preorder(root,last);
    }
private:
    void preorder(TreeNode *node,TreeNode *&last){
        if(!node)return;
        if(!node->left&&!node->right){
            last=node;
            return;
        }
        TreeNode *left=node->left;
        TreeNode *right=node->right;
        TreeNode *left_last=NULL;
        TreeNode *right_last=NULL;\
        if(left){
            preorder(node->left,left_last);
            node->left=NULL;
            node->right=left;
            last=left_last;
        }
        if(right){
            preorder(node->right,right_last);
            if(left_last){
                left_last->right=right;
            }
            last=right_last;
        }
    }
};

Leetcode199从右侧观察二叉树

层次遍历二叉树每层最后一个节点

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
         std::vector<int>view;
        std::queue<std::pair<TreeNode*,int>>Q;
        if(root){
            Q.push(std::make_pair(root,0));
        }
        while(!Q.empty()){
            TreeNode *node=Q.front().first;
            int depth=Q.front().second;
            Q.pop();
            if(depth==view.size()){
                view.push_back(node->val);

            }else{
                view[depth]=node->val;
            }
            if(node->left){
                Q.push(std::make_pair(node->left,depth+1));
            }
            if(node->right){
                Q.push(std::make_pair(node->right,depth+1));
            }
        }
        return view;
    }
};