C++力扣刷题记录——深度优先搜索·DFS（递归前中后序）&&广度优先（队列）（持续更新）

1 海岛数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围

思路
我们可以将二维网格看成一个无向图，竖直或水平相邻的 11 之间有边相连。
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 11，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 11 都会被重新标记为 00。
最终岛屿的数量就是我们进行深度优先搜索的次数。

#include <iostream>
#include<vector>

using namespace std;

class Solution {
public:
	void dps(vector<vector<char>>& grid, int r, int c) {
		grid[r][c] = '0';
		int row = grid.size();
		int col = grid[0].size();
		//右左上下
		if (c + 1 < col&&grid[r][c + 1] == '1')dps(grid, r, c + 1);
		if (c - 1 >= 0 && grid[r][c - 1] == '1')dps(grid, r, c - 1);
		if (r + 1 < row&&grid[r + 1][c] == '1')dps(grid, r + 1, c);
		if (r - 1 >= 0 && grid[r - 1][c] == '1')dps(grid, r - 1, c);
	}
	int numIslands(vector<vector<char>>& grid) {
		int row = grid.size();
		if (!row)return 0;//先判断不然后面的就会越出
		int col = grid[0].size();
		int sum = 0;
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < col; j++) {
				if (grid[i][j] == '1') {
					sum += 1;
					dps(grid, i, j);
				}
			}
		}
		return sum;
	}
};

2 剑指 Offer 55 - I. 二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

思路1
广度搜索，运用队列来迭代

#include <iostream>
#include <queue>
using namespace std;

 //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:
	  int maxDepth(TreeNode* root) {
		  int depth = 0;
		  if (root == nullptr)return 0;
		  queue<TreeNode*> bfs;
		  //把root放进去
		  bfs.push(root);
		  while (!bfs.empty()) {
			  int nums = bfs.size();
			  //统计一下该层有几个 然后拿出来并把后面的子层放进来
			  for (int i = 0; i < nums; i++) {
				  auto node_ptr = bfs.front();
				  bfs.pop();
				  if (node_ptr->left != nullptr)bfs.push(node_ptr->left);
				  if (node_ptr->right != nullptr)bfs.push(node_ptr->right);
			  }
			  ++depth;
		  }
		  return depth;
	  }
  };

思路二：
运用深度优先 max（左树最大。右树最大）+1

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

3 剑指 Offer 55 - II. 平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

思路
所有节点为root的左右子树深度绝对值相差2；
树的深度=max(left,right)+!
第一种：从底部至顶部——后序遍历+剪枝
对二叉树做后序遍历，从底至顶返回子树深度，若判定某子树不是平衡树则 “剪枝” ，直接向上返回

/**
 * 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 isBalanced(TreeNode* root) {
		return recur(root) != -1;
	}
private:
	//剪枝 返回-1就是不行。
	int recur(TreeNode* root) {
		if (root == nullptr)return 0;//root空，那么为叶节点
		int left = recur(root->left);
		//当左（右）子树深度为 -1 ：
		//代表此树的 左（右）子树 不是平衡树，因此剪枝，直接返回 -1
		if (left == -1)return -1;//判断子树 是不是-1
		int right = recur(root->right);
		if (right == -1) return -1;//判断子树是不是 -1；
		return abs(left - right) < 2 ? max(right, left) + 1 : -1;
	}
};

思路二
先序遍历 + 判断深度 （从顶至底）
思路是构造一个获取当前子树的深度的函数
通过比较某子树的左右子树的深度差,来判断某子树是否是二叉平衡树。若所有子树都平衡，则此树平衡。
递归实现 同时需要注意一点：空树也是平衡二叉树

/**
 * 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 isBalanced(TreeNode* root) {
		if (root == nullptr) return 1;
		return abs(depth(root->left) - depth(root->right)) < 2 
			&& isBalanced(root->left) && isBalanced(root->right);
		
	}
private:
	//DFS 从底上开始往上
	int depth(TreeNode* root) {
		if (root == nullptr) return 0;
		return max(depth(root->left), depth(root->right)) + 1;
	}
};

4 114 二叉树展开为单列表

给定一个二叉树，原地将它展开为一个单链表。

思路：
原地就是说，用原来的节点进行重新连接就可以得到结果。
思路就是使用先序排列 把他按照需要的顺序放到一个vector容器中
然后就是把每个节点的顺序换一下。需要注意的地方为第一个节点和最后一个节点在vector中没有位置变换。
还有一个vector中的数据要是想在函数中也变，需要使用引用的格式进行。这个是我开始的时候忘了的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	vector<TreeNode *> list;
	void flatten(TreeNode* root) {
		preorder(root,list);
		int size = list.size();
		for (int i = 0; i < size; i++) {
			list[i]->left = nullptr;
			if (i == size - 1)
				list[i]->right = nullptr;
			else
				list[i]->right = list[i + 1];
		}
	}
private:
	void preorder(TreeNode *root,vector<TreeNode*> &list) {
		if (root == nullptr) return;
		list.push_back(root);
		preorder(root->left,list);
		preorder(root->right,list);
	}
};

5 108 将有序数组转化为二叉平衡树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

思路：
递归，中间的做root
大的区间给右边 小的区间给左边。

/**
 * 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:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return helper(nums, 0, nums.size() - 1);
    }

    TreeNode* helper(vector<int>& nums, int left, int right) {
        if (left > right) {
            return nullptr;
        }

        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;

        TreeNode* root = new TreeNode(nums[mid]);
        root->left = helper(nums, left, mid - 1);
        root->right = helper(nums, mid + 1, right);
        return root;
    }
};