【LeetCode】BFS || DFS [2017.04.10--2017.04.17]

[102] Binary Tree Level Order Traversal [Medium-Easy] 

[107] Binary Tree Level Order Traversal II [Medium-Easy]

这俩题没啥区别。都是二叉树层级遍历。BFS做。

可以用一个队列或者两个队列实现。我觉得一个队列实现的更好。（一个队列实现的重点是利用队列的size来看当前层级的节点数）

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if (!root) {
            return ans;
        }
        queue<TreeNode *> q;
        q.push(root);
        while (!q.empty()) {
            size_t sz = q.size();
            vector<int> level;
            for (auto i = 0; i < sz; ++i) {
                TreeNode* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                if (cur->left) {
                    q.push(cur->left);
                }
                if (cur->right) {
                    q.push(cur->right);
                }
            }
            ans.push_back(level);
        }
        return ans;
    }
};

[101] Symmetric Tree [Easy] 

判断一棵树是不是对称树。为啥还是不能一下子就写出来。。。

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if (!root) return true;
        return isSymmetric(root->left, root->right);
    }
    bool isSymmetric(TreeNode* left, TreeNode* right) {
        if (!left && !right) {
            return true;
        }
        else if (left == nullptr || right == nullptr) {
            return false;
        }
        else if (left->val != right->val){
            return false;
        }
        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
    }
    
};

[542] 01 Matrix [Medium]

给个01矩阵，找到每个cell到 0 entry的最短距离。

从第一个0元素开始BFS, 用队列记录每个 0 元素的位置, 遍历队列，更新一个周围的元素之后，把更新的元素也进队。

队列一定是越来越短的，因为你每pop一个出来，需要更新元素才能push

class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        vector<vector<int>> ans;
        //const int m[4] = {1, 0, -1, 0}; //top - buttom
        //const int n[4] = {0, 1, 0, -1}; //left - right
        const vector<pair<int, int>> dir{{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
        if (matrix.size() == 0 || matrix[0].size() == 0) {
            return ans;
        }  
        const int rows = matrix.size(), cols = matrix[0].size();
        queue<pair<int, int>> q;
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < cols; ++j) {
                if (matrix[i][j] != 0) {
                    matrix[i][j] = INT_MAX;
                }
                else {
                    q.push(make_pair(i, j));
                }
            }
        }
        while (!q.empty()) {
            pair<int, int> xy = q.front();
            q.pop();
            for(auto ele: dir) {
                int new_x = xy.first + ele.first, new_y = xy.second + ele.second;
                if (new_x >= 0 && new_x < rows && new_y >= 0 && new_y < cols) {
                    if (matrix[new_x][new_y] > matrix[xy.first][xy.second] + 1) {
                        matrix[new_x][new_y] = matrix[xy.first][xy.second] + 1;
                        q.push({new_x, new_y});
                    }           
                }
            }
        }
        return matrix;
    }
};