广度优先搜索(BFS)

 

广度优先搜索(BFS)概念

BFS是从根节点开始，沿着树的宽度遍历树的节点。所有节点均被访问，则算法终止。BFS是一种盲目搜索，系统的展开并检查图中所有的节点。

什么情况下当应用BFS搜索

一般适用于求最短、最长路径等问题

例子分析

(1)

解题思路

将陆地一轮又一轮地扩大，直到覆盖完全，计算扩大了多少轮，输出轮数即可，扩大的地方进行赋值，抽象成树的结构

 

int isExistZero(int** grid, int gridSize, int* gridColSize) {
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < *gridColSize; j++) {
            if (grid[i][j] == 0) {
                return 1;
            }
        }
    }
    return 0;
}
int isExistUp(int** grid, int i, int j, int gridSize, int *gridColSize) {
    if (i != 0) {
        return 1;
    }
    return 0;
}
int isExistDown(int** grid, int i, int j, int gridSize, int *gridColSize) {
    if (i != gridSize - 1) {
        return 1;
    }
    return 0;
}
int isExistLeft(int** grid, int i, int j, int gridSize, int *gridColSize) {
    if (j != 0) {
        return 1;
    }
    return 0;
}
int isExistRight(int** grid, int i, int j, int gridSize, int *gridColSize) {
    if (j != *gridColSize - 1) {
        return 1;
    }
    return 0;
}
void infectionOthers(int** grid, int i, int j, int gridSize, int *gridColSize) {
    if (isExistUp(grid, i, j, gridSize, gridColSize) && (grid[i - 1][j] == 0)) {
        grid[i - 1][j] = grid[i][j] + 1;
    }
    if (isExistDown(grid, i, j, gridSize, gridColSize) && (grid[i + 1][j] == 0)) {
        grid[i + 1][j] = grid[i][j] + 1;
    }
    if (isExistLeft(grid, i, j, gridSize, gridColSize) && (grid[i][j - 1] == 0)) {
        grid[i][j - 1] = grid[i][j] + 1;
    }
    if (isExistRight(grid, i, j, gridSize, gridColSize) && (grid[i][j + 1] == 0)) {
        grid[i][j + 1] = grid[i][j] + 1;
    }
}
int maxDistance(int** grid, int gridSize, int* gridColSize){
    int result = 0;
    int zeroNumber = 0;
    int oneNumber = 0;
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < *gridColSize; j++) {
            if (grid[i][j] == 0) {
                zeroNumber++;
            }
            if (grid[i][j] == 1) {
                oneNumber++;
            }
        }
    }
    if (zeroNumber == gridSize * (*gridColSize) || oneNumber == gridSize * (*gridColSize)) {
        return -1;
    }
    while(isExistZero(grid, gridSize, gridColSize)) {
        result ++;
        for (int i = 0; i < gridSize; i++) {
            for (int j = 0; j < *gridColSize; j++) {
                if (grid[i][j] == result) {
                    infectionOthers(grid, i, j, gridSize, gridColSize);
                }
            }
        }
    }
    return result;
}

(2) 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


int calTreeHight(struct TreeNode* root) {
    if (! root) {
        return 0;
    }
    int left = 1 + calTreeHight(root->left);
    int right = 1 + calTreeHight(root->right);
    return left > right ? left : right;
}

bool isBalanced(struct TreeNode* root){
    if (! root) {
        return true;
    }
    int leftHeight = calTreeHight(root->left);
    int rightHeight = calTreeHight(root->right);
    if (abs(leftHeight - rightHeight) > 1) {
        return false;
    }
    return isBalanced(root->left) && isBalanced(root->right);
}

(3)

 

 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isEqual(struct TreeNode* left, struct TreeNode* right)
{
    if (left == NULL && right == NULL) {
        return true;
    }
    if (left == NULL || right == NULL) {
        return false;
    }
    if (left->val != right->val) {
        return false;
    }
    return isEqual(left->left, right->right) && isEqual(left->right, right->left);
}
bool isSymmetric(struct TreeNode* root){
    if (!root) {
        return true;
    }
    if (root->left == NULL && root->right == NULL) {
        return true;
    }
    if (root->left == NULL || root->right == NULL) {
        return false;
    }
    int left = root->left->val;
    int right = root->right->val;
    if (left != right) {
        return false;
    }
    return isEqual(root->left, root->right);
}