广度优先搜索(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);
}