2.1 LeetCode总结（基本算法）

2.1 LeetCode总结（基本算法）_DFS

1.4 练习

104. 二叉树的最大深度

int maxDepth(struct TreeNode *root, int len) 
{if (root == NULL) {return len;}return fmax(maxDepth(root->left, len+1), maxDepth(root->right, len+1));
}

二叉树最大深度就是基本的递归思路的求解，手法主要是递归下去之后len改如何赋值有点搞不清，这里给出了demo的用例，只要能递归就加+1，最后递归到叶子节点返回len。
手法：利用 “递”

111. 二叉树的最小深度

在这里插入图片描述
手法：利用 “归” ，这里不同于二叉树的深度求解，深度是利用递的性质，本题是先递下去，再归时做了处理。（具体见下面代码注释部分）

int minDepth(struct TreeNode *root) {if (root == NULL) {return 0;}if (root->left == NULL && root->right == NULL) {return 1;}int min_depth = INT_MAX; // 手法2：归上来时，要保证每次函数返回值与min_depth的fmin操作时//  函数返回值都能保留下来，所以min_depth要设置最大值.if (root->left != NULL) {min_depth = fmin(minDepth(root->left), min_depth);}if (root->right != NULL) {min_depth = fmin(minDepth(root->right), min_depth);}return min_depth + 1; // 手法1：利用归的特性，先递下去求解到叶子节点的数值，进入到循环终止条件// 然后每层，逐层归上来时+1.
}

049. 求从根节点到叶节点的路径数字之和

在这里插入图片描述

int dfs(struct TreeNode *root, int prevSum) {if (root == NULL) {return 0;}int sum = prevSum * 10 + root->val;if (root->left == NULL && root->right == NULL) {return sum; // 递归终止条件} else {return dfs(root->left, sum) + dfs(root->right, sum);// 先递归下去左叶子节点，计算出来，然后递归右叶子节点}
}int sumNumbers(struct TreeNode *root) {return dfs(root, 0);
}

93. 复原 IP 地址

在这里插入图片描述

#define MAX 166     // 排列组合简单算的，实际没有这么多，很多情况不合法
void dfs(char *s, char **res, int *returnSize, int step, int index, int len, char *temp) 
{if (step == 4) {    // 结束条件：已取完四个数，将结果添加至结果数组res[*returnSize] = (char*)malloc(sizeof(char)*(len + 4));temp[index + step - 1] = '\0';      //将最后一个'.'去掉strcpy(res[*returnSize], temp);(*returnSize)++;return;}// 取一位数；// 剪枝：剩余长度不合法的情况// 剩余长度属于 [(3 - step)， (3 - step) * 3]if ((len - index - 1 <= (3 - step) * 3) && (len - index - 1 >= (3 - step))) {temp[index + step]     = s[index];temp[index + step + 1] = '.';dfs(s, res, returnSize, step + 1, index + 1, len, temp);}// 取两位合法数（首位不为0）； s[index] != '0'// 剪枝：剩余长度不合法的情况if ((len - index - 2 <= (3 - step) * 3) && ((len - index - 2 >= (3 - step)) && (s[index] != '0'))) {temp[index + step]     = s[index];temp[index + step + 1] = s[index + 1];temp[index + step + 2] = '.';dfs(s, res, returnSize, step + 1, index + 2, len, temp);}// 取三位合法数（首位不为0，且<=255）；// 剪枝：剩余长度不合法的情况if ((len - index - 3 <= (3 - step) * 3) && (len - index - 3 >= (3 - step)) && ((s[index] != '0') && ((s[index] - '0') * 100 + (s[index + 1] - '0') * 10 + s[index + 2] - '0' <= 255))) {temp[index + step]     = s[index];temp[index + step + 1] = s[index + 1];temp[index + step + 2] = s[index + 2];temp[index + step + 3] = '.';dfs(s, res, returnSize, step + 1, index + 3, len, temp);}
}char **restoreIpAddresses(char *s, int *returnSize) 
{*returnSize = 0;int len = strlen(s);if (len > 12 || len < 4) {return NULL;     //长度不合法直接return}char **res = (char **)malloc(sizeof(char *) * MAX);char *temp = (char *)malloc(sizeof(char) * (len + 5));dfs(s, res, returnSize, 0, 0, len, temp);return res;
}

130. 被围绕的区域

在这里插入图片描述
注意到题目解释中提到：任何边界上的 O 都不会被填充为 X。我们可以想到，所有的不被包围的 O 都直接或间接与边界上的 O 相连。我们可以利用这个性质判断 O 是否在边界上，具体地说：

对于每一个边界上的 O，我们以它为起点，标记所有与它直接或间接相连的字母 O；
最后我们遍历这个矩阵，对于每一个字母：
如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，我们将其还原为字母 O；
如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，我们将其修改为字母 X

void dfs(char **board, int x, int y, int row, int col)
{if (x < 0 || x >= row || y < 0 || y >= col || board[x][y] != 'O') {  // 从边界的'O'出发遍历与之直接或间接相邻的'O'return;}board[x][y] = 'Z';  // 暂时将与边界上的'O'直接或间接相邻的'O'标记为'Z'dfs(board, x + 1, y, row, col);  // 向下遍历dfs(board, x - 1, y, row, col);  // 向上遍历dfs(board, x, y + 1, row, col);  // 向右遍历dfs(board, x, y - 1, row, col);  // 向左遍历
}void solve(char **board, int boardSize, int *boardColSize)
{if (board == NULL || boardSize == 0 || (*boardColSize) == 0) {return;}int row = boardSize;int col = (*boardColSize);int i, j;for (i = 0; i < col; i++) {  // 寻找与第一行的'O'直接或间接相邻的'O'if (board[0][i] == 'O') {dfs(board, 0, i, row, col);}// 寻找与最后一行的'O'直接或间接相邻的'O'if (board[row - 1][i] == 'O') {dfs(board, row - 1, i, row, col);}}for (i = 0; i < row; i++) {  // 寻找与第一列的'O'直接或间接相邻的'O'if (board[i][0] == 'O') {dfs(board, i, 0, row, col);}// 寻找与最后一列的'O'直接或间接相邻的'O'if (board[i][col - 1] == 'O') {dfs(board, i, col - 1, row, col);}}// 结果for (i = 0; i < row; i++) {  // 将被'X'围绕的'O'转换为'X'for (j = 0; j < col; j++) {if (board[i][j] == 'O') {board[i][j] = 'X';}else if (board[i][j] == 'Z') { // 之前将不被'X'围绕的'O'转换为'Z'，现在恢复为'O'board[i][j] = 'O';}}}
}

22. 括号生成

在这里插入图片描述

// 回溯法求解
#define MAX_SIZE 1430  // 卡特兰数: 1, 1, 2, 5, 14, 42, 132, 429, 1430
void generate(int left, int right, int n, char *str, int index, char **result, int *returnSize) 
{if (index == 2 * n) { // 当前长度已达2nresult[(*returnSize)] = (char *)malloc((2 * n + 1) * sizeof(char));memset(result[(*returnSize)], 0, (2 * n + 1) * sizeof(char));strcpy(result[(*returnSize)++], str);return;}// 如果左括号数量不大于 n，可以放一个左括号if (left < n) {str[index] = '(';generate(left + 1, right, n, str, index + 1, result, returnSize);}// 如果右括号数量小于左括号的数量，可以放一个右括号if (right < left) {str[index] = ')';generate(left, right + 1, n, str, index + 1, result, returnSize);}
}
/*** Note: The returned array must be malloced, assume caller calls free().*/
char **generateParenthesis(int n, int *returnSize)
{char *str = (char *)malloc((2 * n + 1) * sizeof(char));memset(str, 0 ,(2 * n + 1) * sizeof(char));char **result = (char **)malloc(sizeof(char *) * MAX_SIZE);*returnSize = 0;generate(0, 0, n, str, 0, result, returnSize);return result;
}