树/图的练习

113. 路径总和 II

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 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/path-sum-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */ 
void pre_order(TreeNode *node, int sum,int value, vector<vector<int> > &result, vector<int> &road)
 {
     if(node == nullptr)
        return;
     value += node->val;
     road.push_back(node->val);
     if(node->left == nullptr && node->right == nullptr && value == sum)
     {
         result.push_back(road);
     }
     pre_order(node->right,sum,value,result,road);
     pre_order(node->left,sum,value,result,road);
     road.pop_back();

 }
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int> > result;
        vector<int>road;
        pre_order(root,sum,0,result,road);
        return result;

    }
};

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

 

 

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
 

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

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

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

 void pre_order(TreeNode *node,TreeNode*isearch,vector<TreeNode*> &path,vector <TreeNode*> &result,int &finish)
 {
     if(node == NULL ||finish == 1)
     {
         return;
     }
     path.push_back(node);
     if(node == isearch)
     {
         finish = 1;
         result = path;
     }
     pre_order(node->left,isearch,path,result,finish);
     pre_order(node->right,isearch,path,result,finish);
     path.pop_back();

 }
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    vector<TreeNode*> p_path;
    vector<TreeNode*> q_path;
    vector<TreeNode*> path;
    int finish =0;
    int len;
    pre_order(root,p,path,p_path,finish);
    path.clear();
    finish = 0;
    pre_order(root,q,path,q_path,finish);
    if(p_path.size() > q_path.size())
    {
        len = q_path.size();
    }
    else
    {
        len = p_path.size();
    }
    TreeNode * result;
    for(int i=0 ; i< len;i++)
    {
        if(p_path[i] == q_path[i])
        {
            result = p_path[i];
        }
    }
    return result;
    }
};

 

114. 二叉树展开为链表

给定一个二叉树，原地将它展开为链表。

例如，给定二叉树

1
/ \
2 5
/ \ \
3 4 6
将其展开为：

1
\
2
\
3
\
4
\
5
\
6

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

/**
 * 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:
    void flatten(TreeNode* root) {
        TreeNode*last = NULL;
        preorder(root,last);
    }
private:
    void preorder(TreeNode*node,TreeNode *&last)
    {
        if(node == NULL)
            return;
        if(node->left == NULL && node->right == NULL)
        {

            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;
            left_last->right = right;
            last = left_last;
        }
        if(right)
        {

            preorder(node->right,right_last);
            if(left_last)
            {
                left_last->right = right;
            }
            last = right_last;
        }
    }
};

插播一个层序遍历 也就是bfs

void bfs_print(TreeNode* root)
{
    queue<TreeNode*> Q;
    Q.push(root);

    while(!Q.empty())
    {
        TreeNode *node = Q.front();
        Q.pop();
        cout<<node->val<<" ";
        if(node->left != NULL)
        Q.push(node->left);
        if(node->right != NULL)
        Q.push(node->right);
    }
    
}

 

 

199. 二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

1 <---
/ \
2 3 <---
\ \
5 4 <---

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

/**
 * 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<int> rightSideView(TreeNode* root) {
    vector<int> result;
    queue<pair<TreeNode*,int> > Q;
    if(root!= NULL)
    {
        Q.push(make_pair(root,0));
    }
    while(!Q.empty())
    {
        TreeNode* node = Q.front().first;
        int deep = Q.front().second;
        Q.pop();
        if(result.size() == deep)
        {
            result.push_back(node->val);
        }
        else//不是新层，只更新当前层的val
        {
            result[deep] = node->val;
        }
        if(node->left)
        {
            Q.push(make_pair(node->left,deep+1));
        }
        if(node->right)
        {
            Q.push(make_pair(node->right,deep+1));
        }
    }
    return result;
    }
};

 

207. 课程表

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？

示例 1:

输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

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

dfs

struct GraphNode
{
    int lable;
    vector<GraphNode*> neighbors;
    GraphNode(int x):lable(x){};
};

bool DFS_graph(GraphNode*node,vector<int> &visit)
{
    visit[node->lable] = 0;
    for(int i = 0; i < node->neighbors.size();i++)
    {
        if(visit[node->neighbors[i]->lable] == -1)
        {
            if(!DFS_graph(node->neighbors[i],visit))
            {
                return false;
            }
        }
        else if(visit[node->neighbors[i]->lable] == 0)
        {
            return false;
        }
    }
    visit[node->lable] = 1;
    return true;
}
class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int> >& prerequisites) {
    vector<GraphNode*> graph;//邻接表
    vector<int> visit;//-1表示未访问，0表示正在访问，1表示已经访问
    for(int i = 0; i < numCourses;i++)
    {
        graph.push_back(new GraphNode(i));//创建图的节点，并赋值访问状态为空
        visit.push_back(-1);
    }
    for(int i = 0; i <prerequisites.size();i++)
    {
        GraphNode *begin = graph[prerequisites[i][1]];
        GraphNode *end = graph[prerequisites[i][0]];
        begin->neighbors.push_back(end);
    }
    for(int i = 0; i < prerequisites.size();i++)
    {
        if(visit[i] == -1 && !DFS_graph(graph[i],visit))//在节点没有访问过且遇到环的情况下返回false
            return false;
    }
    for(int i = 0; i < numCourses;i++)
    {
        delete graph[i];
    }
    return true;
    }
};

 

bfs

struct GraphNode
{
    int lable;
    vector<GraphNode*> neighbors;
    GraphNode(int x):lable(x){};
};

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int> >& prerequisites) {
    vector<GraphNode*> graph;//邻接表
    vector<int> degree;//入度数组
    for(int i = 0; i < numCourses;i++)
    {
        degree.push_back(0);
        graph.push_back(new GraphNode(i));
    }
    for(int i = 0; i <prerequisites.size();i++)
    {
        GraphNode*begin = graph[prerequisites[i][1]];
        GraphNode*end = graph[prerequisites[i][0]];
        begin->neighbors.push_back(end);
        degree[prerequisites[i][0]]++;
    }
    queue<GraphNode*> Q;
    for(int i = 0; i < numCourses;i++)
    {
        if(degree[i] == 0)
        Q.push(graph[i]);
    }
    while(!Q.empty())
    {
        GraphNode*node = Q.front();
        Q.pop();
        for(int i = 0; i <node->neighbors.size();i++)
        {
            degree[node->neighbors[i]->lable]--;
            if(degree[node->neighbors[i]->lable] == 0)
                Q.push(node->neighbors[i]);
        }
    }
    for(int i = 0; i < degree.size();i++)
    delete graph[i];
   for(int i = 0; i < degree.size();i++)
   {
       if(degree[i])
        return false;
   }
   return true;
    }
};