107. 二叉树的层次遍历

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

STL queue：

原理：队尾（rear）插入，队首（front）删除

头文件： 

1
#include<queue>

方法：

1
2
3
4
5
6
push(): 推一个元素进队列
front(): 返回队首元素(栈对应的是top())
back(): 返回队尾元素
pop(): 移除队首元素
empty()
size()

创建：

1
queue<string> q;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/**
 * 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>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> resV;
        vector<int> levelNumV;
        TreeNode* cur = root;
        //层次遍历借助队列实现
        queue<TreeNode*> q;
        q.push(cur);
        //跳出遍历的条件为队列为空
        while(!q.empty())
        {
            int size = q.size();
            while(size-- > 0)
            {
                cur = q.front();
                //砍头操作
                q.pop();
                if(cur)
                {
                levelNumV.push_back(cur->val);
                //爆菊操作
                q.push(cur->left);
                q.push(cur->right);
                }
            }
            if(!levelNumV.empty())
            {
            //输出格式不是规则的二维数组可选用vector<vector>，它的push_back内容为vector（不限制子vector长度）
            resV.push_back(levelNumV);
            levelNumV.clear();
            }
        }
        //vector中reverse的使用
        reverse(resV.begin(), resV.end());
        return resV;
    }
};

207. 课程表

你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。

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

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

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

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

我们就可以将本题建模成一个求拓扑排序的问题了：

我们将每一门课看成一个节点

如果想要学习课程 A之前必须完成课程 B，那么我们从B到A连接一条有向边。这样以来，在拓扑排序中，B一定出现在 A的前面

思路：

考虑拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后，我们就可以移除它的所有出边，代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了「没有任何入边的节点」，那么就代表着这门课可以开始学习了。按照这样的流程，我们不断地将没有入边的节点加入答案，直到答案中包含所有的节点（得到了一种拓扑排序）或者不存在没有入边的节点（图中包含环）

算法：

使用一个队列来进行广度优先搜索。初始时，所有入度为 00 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且它们之间的相对顺序是无关紧要的。

在广度优先搜索的每一步中，我们取出队首的节点u：

我们将u放入答案中

我们移除 u的所有出边，也就是将u的所有相邻节点的入度减少1。如果某个相邻节点v的入度变为0，那么我们就将v放入队列中

在广度优先搜索的过程结束后。如果答案中包含了这n个节点，那么我们就找到了一种拓扑排序，否则说明图中存在环，也就不存在拓扑排序了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
    //入度 in degree
    vector<int> indeg;
    vector<vector<int>> edges;
    //resize内的默认初始化值为0
    indeg.resize(numCourses);
    edges.resize(numCourses);
    for (const auto& info : prerequisites)
    {
        //以info[1]为起始的边，指向info[0]
        edges[info[1]].push_back(info[0]);
        //info[0]的入度加一，指向它的是info[1]
        ++indeg[info[0]];
    }
    queue<int> q;
    for (int i = 0; i < numCourses; i++)
    {
        //把最开始入度为0的点push进去
        if (indeg[i] == 0)
        {
            q.push(i);
        }
    }
    int visited = 0;
    while (!q.empty())
    {
        visited++;
        int u = q.front();
        q.pop();
        for (int v : edges[u])
        {
            --indeg[v];
            //如果去掉指向它的u之后，v点的入度变为0，那么push进队列
            if (indeg[v] == 0)
            {
                q.push(v);
            }
        }
    }
    return visited == numCourses;
}