DFS和BFS——算法（二）

二叉树的右视图 中等
BFS
广度优先搜索，利用队列来实现

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        if (root == NULL) return {};
        vector<int> res;
        queue<TreeNode*> que; que.push(root);
        while (!que.empty()){
            int len = que.size();
            for (int i=0; i<len; i++){
                auto temp = que.front();
                que.pop();
                if (i == len-1)
                    res.push_back(temp->val);
                if (temp->left != NULL) que.push(temp->left);
                if (temp->right != NULL) que.push(temp->right);
            }
        }
        return res;
    }
};

DFS，主要利用递归

class Solution {
    vector<int> res;
public:
    void dfs(TreeNode* root, int depth) {
        if (root == NULL) return;
        // 先访问 当前节点，再递归地访问 右子树 和 左子树。
        // 如果当前节点所在深度还没有出现在res里，说明在该深度下当前节点是第一个被访问的节点，因此将当前节点加入res中。
        if (depth == res.size())  
            res.push_back(root->val);
        depth++;
        dfs(root->right, depth);//注意这里是先访问右节点
        dfs(root->left, depth);
    }
    vector<int> rightSideView(TreeNode* root) {
        if (root == NULL) return {};
        dfs(root, 0);
        return res;
    }
};

剑指 Offer 13. 机器人的运动范围 中等
BFS

class Solution {
    int dir[2][2] = {1,0,0,1};
    int BFS(vector<vector<int>>& matrix, int k){
        queue<pair<int,int>> que; que.push(pair<int,int>(0,0));
        int res = 1; matrix[0][0] = 1;
        while (!que.empty()){
            auto temp = que.front();
            que.pop();
            for (int i=0; i<2; i++){
                int x = temp.first + dir[i][0];
                int y = temp.second + dir[i][1];
                if (x >= matrix.size() || y >= matrix[0].size() || x/10+x%10+y/10+y%10>k)
                    continue;
                if (matrix[x][y] == 1){
                    matrix[x][y] = 0;
                    res++;
                    que.push(pair<int,int>(x,y));
                }
            }
        }
        return res;
    }
public:
    int movingCount(int m, int n, int k) {
        vector<vector<int>> matrix(m, vector<int>(n, 1));
        return BFS(matrix, k);
    }
};

DFS

class Solution {
    int res = 0;
    void DFS(vector<vector<int>>& matrix, int i, int j, int k){
        if (i<0 || j<0 || i>=matrix.size() || j>=matrix[0].size() || i/10+i%10+j/10+j%10>k)
            return;
        if (matrix[i][j] == 1){
            matrix[i][j] = 0;
            res += 1;
            DFS(matrix,i-1,j,k);
            DFS(matrix,i,j-1,k);
            DFS(matrix,i+1,j,k);
            DFS(matrix,i,j+1,k);
        }
    }
public:
    int movingCount(int m, int n, int k) {
        vector<vector<int>> matrix(m, vector<int>(n, 1));
        DFS(matrix, 0, 0, k);
        return res;
    }
};

快排实现
DFS

class Solution {
    void quickSort(vector<int>& nums, int l, int r){
        if (l >= r) return;
        int mark = nums[l];
        int mark_ptr = l;
        for (int i=l; i<=r; i++){
            if (nums[i] < mark){
                mark_ptr++;
                swap(nums[i], nums[mark_ptr]);
            }
        }
        swap(nums[mark_ptr], nums[l]);
        quickSort(nums, l, mark_ptr-1);
        quickSort(nums, mark_ptr+1, r);
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};

快排非递归实现，利用栈，BFS的思想，存储前后指针

class Solution {
    void quickSort(vector<int>& nums, int l, int r){
        using Pair = pair<int,int>;
        stack<Pair> stk; stk.push(Pair(l, r));
        while (!stk.empty()){
            auto index = stk.top(); stk.pop();
            int l = index.first; int r = index.second;
            if (l >= r) continue;
            int mark = nums[l];
            int mark_ptr = l;
            for (int i=l; i<=r; i++){
                if (nums[i] < mark){
                    mark_ptr++;
                    swap(nums[i], nums[mark_ptr]);
                }
            }
            swap(nums[mark_ptr], nums[l]);
            stk.push(Pair(l, mark_ptr-1));
            stk.push(Pair(mark_ptr+1, r));
        }
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};