二叉树5：二叉树层序遍历

news2024/11/27 6:16:24

学会二叉树的层序遍历，可以一口气打完以下十题：
强烈建议大家和我一样，先看一下第一道题，大家可以去看看卡哥的哔站视频，理解透。然后后面的九道题自己先动手做一下，别急着看答案，真心不难，做完会很成就感。
102.二叉树的层序遍历
107. 二叉树的层序遍历 II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

我自己提前打了一遍在看的解析，感觉确实学完了层序遍历之后就不难。大家也可以试试。

102.二叉树的层序遍历

链接: 102.二叉树的层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例 1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

实现的思路：队列不空的话同时记录队列大小，我们就一次取出头节点，，访问该节点，然后把这个节点的所有孩子节点在加入队列中，
使用队列实现二叉树广度优先遍历，动画如下：
请添加图片描述
这样就实现了层序从左到右遍历二叉树。

代码如下：这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了。

C++代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

# 递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);//处理节点
        order(cur->left, result, depth + 1);//处理左孩子
        order(cur->right, result, depth + 1);//处理右孩子
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

107.二叉树的层次遍历 II

链接: 107. 二叉树的层序遍历 II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

思路：

相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。

C++代码：

//递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
		if (cur == nullptr) return;
		if (result.size() == depth) result.push_back(vector<int>());
		result[depth].push_back(cur->val);			//处理节点
		order(cur->left, result, depth + 1);		//处理左孩子
		order(cur->right, result, depth + 1);		//处理右孩子
	}

    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
		int depth = 0;
		order(root, result, depth);
		
		reverse(result.begin(), result.end());
		/*int left=0, right=result.size()-1;  		//这句代码也可以替换为下面的，不过自己写的执行效率更低
		while (left < right) 
			swap(result[left++], result[right--]);*/
		return result;
    }
};

//迭代法
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end()); // 在这里反转一下数组即可
        return result;

    }
};

199.二叉树的右视图

链接: 199.二叉树的右视图
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例

示例 1:
在这里插入图片描述

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100

思路：

  1. 层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
  2. 每一层在容器中一直维持一个元素，直到他为最右边的节点。

C++代码：

//迭代法
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val); // 将每一层的最后元素放入result数组中（要找最左边的让他等于0 就好了）
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

//递归法
class Solution {
public:
   void order(TreeNode* cur, vector<int>& result, int depth) {
		if (cur == nullptr) return;
		if (result.size() == depth)result.push_back(0);		//临时的占位符
		result[depth]=cur->val;						//每一层只保留最后一次处理的节点，即最右边的节点
		order(cur->left, result, depth + 1);		//处理左孩子	//换一下处理孩子的顺序就可以看左视图，大家可以试试哦
		order(cur->right, result, depth + 1);		//处理右孩子
	}

	vector<int> rightSideView(TreeNode* root) {
		vector<int> result;
		int depth = 0;
		order(root, result, depth);
		return result;
	}
};

637.二叉树的层平均值

链接: 637.二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。
示例 2:

在这里插入图片描述

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

树中节点数量在 [1, 104] 范围内
-231<= Node.val <= 231 - 1

思路:

本题就是层序遍历的时候把一层求个总和在取一个均值。
其实这个思路不难，但是我刚好复习的时候学到了一个函数对象（总想嘚瑟一下 是吧。大家可以参考一下，毕竟多复习一点知识），就试着用了一下，感觉还行。

C++代码：

//卡哥的代码（一如既往地简单高效）
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;
        while (!que.empty()) {
            int size = que.size();
            double sum = 0; // 统计每一层的和
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum / size); // 将每一层均值放进结果集
        }
        return result;
    }
};

//我自己写的代码，有一点点拉胯（迭代法）   时间上击败95.77%
class Solution {
public:
	class average {					//函数对象：他可以有自己的状态，用起来的时候和函数差不多，但是他实际是一个对象冲在了（）运算符。
	private:
		vector<double>* result2;	//用来存平均值数组
	public:
		average(vector<double>* result) :result2(result){}  //含参构造函数应该不用解释吧
		void operator()(const vector<int>& vec){
			double sum=0;
			for (auto& num : vec) {
				sum += num;
			}
			result2->push_back(sum / vec.size());
		}
	};
	
	//还是用卡哥的模板，自己尝试了一下for_each函数
	void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
		if (cur == nullptr) return;
		if (result.size() == depth)result.push_back(vector<int>());
		result[depth] .push_back(cur->val) ;		//处理节点
		order(cur->left, result, depth + 1);		//处理左孩子
		order(cur->right, result, depth + 1);		//处理右孩子
	}

	vector<double> averageOfLevels(TreeNode* root) {
		vector<vector<int>> result;
		int depth = 0;
		order(root, result, depth);
		vector<double> result2;
		for_each(result.begin(), result.end(), average(&result2));
		return result2;
	}
};

for_each总结：

void operator()(const vector<int>& vec)   中的const vector<int>& vec其实就是迭代器中的每一个元素，
我这边用引用传递是为了提高效率，避免反复拷贝，const是可以避免修改他的值 。
其实还有一个办法就是 for_each 可以直接返回我们的这个 vector<double>* result2;//用来存平均值数组

下面是我调试这个函数对象的过程，大家看得到他只是走void operator()里面的具体操作过程，因为他默认是每个元素都拿到了，就不用走到void operator()的91行这一步。（不知道这么理解对不对，如果有问题希望大家可以一起在评论区交流）
在这里插入图片描述

429.N叉树的层序遍历

链接: 429.N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例

示例 1：
在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：
在这里插入图片描述

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

树的高度不会超过 1000
树的节点总数在 [0, 104] 之间

思路:

这道题依旧是模板题，只不过一个节点有多个孩子了,大家先看看这个数的结构，使用vector数组来管理孩子节点的。

C++代码:

class Node {
public:
    int val;
    vector<Node*> children;
    Node() {}
    Node(int _val) {val = _val;}
    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};

//卡哥的代码
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (int i = 0; i < node->children.size(); i++) { // 将节点孩子加入队列
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};
//我自己写的和他的差不多，我for循环用的是C++11的范围for循环。
class Solution {
public:
	vector<vector<int>> levelOrder(Node* root) {
		vector<vector<int>>result;
		queue<Node*>myQueue;
		Node* cur = root;
		if (root != nullptr) myQueue.push(root);
		while (!myQueue.empty()) {
			int size = myQueue.size();
			vector<int>temp;
			while (size--) {
				Node* tempNode = myQueue.front();
				temp.push_back(tempNode->val);
				myQueue.pop();
				for (Node* tempN : tempNode->children) {
					myQueue.push(tempN);
				}
			}
			result.push_back(temp);
		}
		return result;
	}
};

515.在每个树行中找最大值

链接: 515.在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例

示例1：
在这里插入图片描述

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示：

二叉树的节点个数的范围是 [0,104]
-231 <= Node.val <= 231 - 1

思路：

层序遍历，取每一层的最大值

C++代码：

//卡哥的代码
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN; // 取每一层的最大值
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue); // 把最大值放进数组
        }
        return result;
    }
};

//明明迭代那么简单，我自己还是想玩玩递归走了一点点弯路
class Solution {//这个方法是先遍历所有的节点存起来，然后再找最大值。
public:
	void dfs(TreeNode* node, vector<vector<int>>&temp, int dpeth) {
		if (node == nullptr) return;
		if (temp.size() == dpeth)  temp.push_back(vector<int>());		//从第零层开始就放一个空数组
		temp[dpeth].push_back(node->val);								//处理节点
		if (node->left)	 dfs(node->left, temp, dpeth + 1);				//处理子节点
		if (node->right) dfs(node->right, temp, dpeth + 1);				//处理子节点
	}
	
	vector<int> largestValues(TreeNode* root) {
		vector<vector<int>>temp;
		vector<int>maxVec;
		int dpeth=0;
		dfs(root, temp, dpeth);
		for (auto tempVec : temp) {
			int maxval = INT_MIN;
			for (auto num : tempVec)
				maxval = max(maxval,num);
			maxVec.push_back(maxval);
		}
		return maxVec;
	}
};


class Solution {//这个方法是直接遍历的时候找最大值。
public:
    void dfs(vector<int>& res, TreeNode* root, int curHeight) {
        if (curHeight == res.size()) 
            res.push_back(root->val);
        else 
            res[curHeight] = max(res[curHeight], root->val);  //只存最大值。
        if (root->left)  dfs(res, root->left, curHeight + 1);
        if (root->right) dfs(res, root->right, curHeight + 1);
    }

    vector<int> largestValues(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        dfs(res, root, 0);
        return res;
    }
};

116.填充每个节点的下一个右侧节点指针

链接: 116.填充每个节点的下一个右侧节点指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例

示例 1：
在这里插入图片描述

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

提示：

树中节点的数量在 [0, 212 - 1] 范围内
-1000 <= node.val <= 1000

思路:

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。我的是遍历的时候让本节点指向下一个节点，最后特殊处理尾节点。

C++代码：

//卡哥的代码
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};
//我的代码逻辑上可能好理解一些，就是每一行中 每次取出元素时候都指向队列的队头元素，同时加入他的子节点进队列中，处理最后一个的时候就不指元素了（他本是就是指向nullptr）
class Solution {
public:
    Node* connect(Node* root) {
		queue<Node*>myQueue;
		if (!root) return nullptr;
		else myQueue.push(root);
		
		while (!myQueue.empty()) {
			int size = myQueue.size();
			while (size--) {
				if (size > 0 ) {
					Node* tempNode = myQueue.front();
					myQueue.pop();
					tempNode->next = myQueue.front();

					if (tempNode->left) myQueue.push(tempNode->left);
					if (tempNode->right) myQueue.push(tempNode->right);
				}
				else {
					Node* tempNode = myQueue.front();
					myQueue.pop();
					if (tempNode->left) myQueue.push(tempNode->left);
					if (tempNode->right) myQueue.push(tempNode->right);
				}
			}
		}
		return root;
	}
};

117.填充每个节点的下一个右侧节点指针II

链接: 117.填充每个节点的下一个右侧节点指针II
给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

在这里插入图片描述

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，
如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

提示：

树中的节点数小于 6000
-100 <= node.val <= 100

思路：

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

C++代码：

//卡哥的代码
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;
    }
};

class Solution {
public:
    Node* connect(Node* root) {
		queue<Node*>myQueue;
		if (!root) return nullptr;
		else myQueue.push(root);
		
		while (!myQueue.empty()) {
			int size = myQueue.size();
			while (size--) {
				if (size > 0 ) {
					Node* tempNode = myQueue.front();
					myQueue.pop();
					tempNode->next = myQueue.front();

					if (tempNode->left) myQueue.push(tempNode->left);
					if (tempNode->right) myQueue.push(tempNode->right);
				}
				else {
					Node* tempNode = myQueue.front();
					myQueue.pop();
					if (tempNode->left) myQueue.push(tempNode->left);
					if (tempNode->right) myQueue.push(tempNode->right);
				}
			}
		}
		return root;
	}
};

104.二叉树的最大深度

链接: 104.二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

思路：

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：
在这里插入图片描述
所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。

C++代码如下：

//卡哥的代码
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:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

//其实用递归也挺简单的。
class Solution {
public:
	void dfs(TreeNode* node, int depth, int& maxdepth) {
		if (!node) return;
		maxdepth = max(maxdepth, depth); //最大深度和当前深度比 取最大
		if(node->left)  dfs(node->left, depth+1, maxdepth);
		if (node->right) dfs(node->right, depth + 1, maxdepth);
	}

	int maxDepth(TreeNode* root) {
		if (!root) return 0;
		int depth = 1;
		int maxdepth = 1;
		dfs(root, depth, maxdepth);
		return maxdepth;
	}
};

111.二叉树的最小深度

链接: 111.二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

示例

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000

思路

相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

代码如下：

//卡哥的代码
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

//力扣的代码，我自己想用上面的104.二叉树的最大深度的递归改出来，没实现。
class Solution {
    public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int m1 = minDepth(root->left);
        int m2 = minDepth(root->right);
        //1.如果左孩子和右孩子有为空的情况，直接返回m1+m2+1
        //2.如果都不为空，返回较小深度+1
        return root->left == nullptr || root->right == nullptr ? m1 + m2 + 1 : min(m1,m2) + 1;
    }
};
复杂度分析

时间复杂度：O(N)，其中 N是树的节点数。对每个节点访问一次。
空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。
平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(logN)。

总结

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/92228.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Git流程规范

Git流程规范

开发新功能 1、从master拉一个功能分支&#xff0c;取名为某个版本下的某个产品功能 4.3/精确发券 2、当功能开发好了&#xff0c;合并分支到dev进行联调 3、如果是俩个关联性的分支&#xff0c;应该把分支合并到另外一个分支&#xff0c;在合并到dev分支中。如图。feature3…
阅读更多...
【学习笔记01】vue的了解和指令

【学习笔记01】vue的了解和指令

一、什么是 Vue&#xff1f; Vue (发音为 /vjuː/&#xff0c;类似 view) 是一款用于构建用户界面的JavaScript框架。它基于标准 HTML、CSS 和 JavaScript 构建&#xff0c;并提供了一套声明式的、组件化的编程模型&#xff0c;帮助你高效地开发用户界面。 二、Vue的两个核心功…
阅读更多...
Day831.局部变量为什么是线程安全的 -Java 并发编程实战

Day831.局部变量为什么是线程安全的 -Java 并发编程实战

局部变量为什么是线程安全的 Hi&#xff0c;我是阿昌&#xff0c;今天学习记录的是关于局部变量为什么是线程安全的。 一遍一遍重复再重复地讲到&#xff0c;多个线程同时访问共享变量的时候&#xff0c;会导致并发问题。 那在 Java 语言里&#xff0c;是不是所有变量都是共…
阅读更多...
【java设计】：全民飞机大战小游戏制作

【java设计】：全民飞机大战小游戏制作

文章目录 前言 一、全民飞机大战 二、计划安排 三、源码图和类图展示
阅读更多...
CTF Android逆向 -- KGB Messenger APK文件结构介绍，破解账户与密码，静态分析，修改并构建APK，逆向算法，APK文件签名

CTF Android逆向 -- KGB Messenger APK文件结构介绍，破解账户与密码，静态分析，修改并构建APK，逆向算法，APK文件签名

前言 一次练习Android逆向的记录&#xff0c;写得很详细&#xff0c;有什么没有理解的地方可以私信 csdn不让我加外链&#xff0c;所以将链接前面的#号去掉即可 题目&#xff1a; ht#tps://github.com/tlamb96/kgb_messenger在这个挑战中&#xff0c;一共有三个flag&#x…
阅读更多...
UE4 Pak打包、挂载、加载

UE4 Pak打包、挂载、加载

首先&#xff0c;必须得明确的一点就是如果想要加载Pak内资源&#xff0c;那么这些资源必须是经过Cook的。如果打包的是未Cook的资源&#xff0c;那么即使Pak挂载成功&#xff0c;也不可能会成功加载Pak内资源。 不知道怎么生成Cook资源&#xff0c;可以看我前一篇 ​​​​​…
阅读更多...
持之以恒，方得始终｜海联捷讯的六年数字化历程

持之以恒，方得始终｜海联捷讯的六年数字化历程

企业数字化已经成为了企业家与管理者的共识。如何实现数字化转型&#xff0c;从认知到战略&#xff0c;上至组织文化&#xff0c;下至每个组织成员的行为&#xff0c;都需要做出改变——它本质上是一种创新的企业管理模式和运营机制&#xff0c;重要性不言而喻。而降本增效也是…
阅读更多...
学习-＞C++篇十七：C++的类型转换和IO流

学习-＞C++篇十七：C++的类型转换和IO流

目录 一.类型转换 1.C语言中的类型转换 2.C中的类型转换 二.IO流 1. C语言的输入与输出 2. 流是什么 3. stringstream 一.类型转换 1.C语言中的类型转换 &#xff08;1&#xff09;隐式类型转换&#xff0c;编译阶段自动进行&#xff0c;不能转换就编译报错。&#xff…
阅读更多...
TCP/IP四层协议

TCP/IP四层协议

七层模型层数太多记不住&#xff0c;四层模型 应用层&#xff0c;传输层&#xff0c;网络层&#xff0c;网络接口层的名字必须记得滚瓜烂熟。&#xff08;重点也是tcp/ip四层模型&#xff09; 四层模型&#xff1a; 1.应用层&#xff1a; 两台终端设备上的应用程序 应该遵守…
阅读更多...
三面美团 Java 岗，HR 现场直接发 offer，他是横着走出来的

三面美团 Java 岗，HR 现场直接发 offer，他是横着走出来的

前情提要 这是一个发生在我朋友身上的真实事情&#xff1a; 这里就叫他程序员 Y 吧。 程序员 Y 工作不到两年&#xff0c;周末在朋友圈发了个喜报&#xff0c;准备入职美团。 之后&#xff0c;我就带着祝福跟 Y 聊了许久&#xff0c;聊天的内容就是具体了解一下他面试的过程…
阅读更多...
技术分享之IntelliJ plugin

技术分享之IntelliJ plugin

资料 https://zhaojian.blog.csdn.net/article/details/127882946 Plugin Configuration File https://plugins.jetbrains.com/docs/intellij/plugin-configuration-file.html 今天分享的主要内容: 了解插件能够做什么 如何开发一个插件 阅读两个常用的插件源码 intellij的窗…
阅读更多...
15.Django大型电商项目之创建模型与sql表反向生成模型

15.Django大型电商项目之创建模型与sql表反向生成模型

1.用户模块模型类创建 1.1 创建用户的子应用 python .\manage.py startapp userapp在settings中挂载子应用 创建子应用urls.py 在主应用中加入子应用的urls.py 1.2 创建表 如何在直接导入sql文件形成表&#xff0c;这里就直接在navicate中把sql文件拖进去点击开始即可 这里…
阅读更多...
大数据技术系列：图解大数据平台开发

大数据技术系列：图解大数据平台开发

导言 在前面的文章《「大数据技术体系」学习实践导览》中&#xff0c;概要式的梳理了大数据平台的业务目标&#xff0c;大数据平台的架构框架&#xff0c;大数据平台中常用的技术及工具&#xff0c;数据治理四方面的内容&#xff0c;算是对自身所了解大数据知识体系的抛砖引玉…
阅读更多...
第十四届蓝桥杯集训——JavaC组第十二篇——while循环(循环四要素)

第十四届蓝桥杯集训——JavaC组第十二篇——while循环(循环四要素)

第十四届蓝桥杯集训——JavaC组第十二篇——while循环(循环四要素) 前言 百度解析&#xff1a;以环形、回路或轨道运行;沿曲折的路线运行;特指运行一周而回到原处,再转。或说反复地连续做某事。 那么&#xff0c;在程序中依然是连续重复的按照一定的规则去执行某事。 程序计数器…
阅读更多...
如何把视频分屏？教你轻松学会视频分屏

如何把视频分屏？教你轻松学会视频分屏

分屏视频该怎么操作&#xff1f;不知道大家有没有看到过这样一个视频&#xff0c;就是一个视频里有两个或者有更多个画面&#xff0c;我们在观看的时候可以同时看好几个画面。其实这就是分屏视频&#xff0c;在一个页面中加入多个画面。这样的视频是不是既好玩又炫酷呢&#xf…
阅读更多...
尚硅谷Promise笔记

尚硅谷Promise笔记

文章目录一、Promise介绍与基本使用1-1.初体验之promise封装ajax请求1-2.Promise对象状态属性PromiseState的值有三个1-3.Promise对象状态属性PromiseResults二、Promise API2-1.Promise构造函数Promise(excutor){}2-2.Promise.prototype.then 方式&#xff1a;(onResolved,onR…
阅读更多...
App 黑白化技术实践

App 黑白化技术实践

前言 很高兴遇见你~ 最近打开各大 App 会发现它们都做了黑白化&#xff0c;如下支付宝的处理&#xff1a; 可以看到应用设置了全局灰色调&#xff0c;表达了一种对逝者的哀悼&#xff0c;非常的应景和人性化。作为程序猿&#xff0c;我们来探索一下它从技术角度是怎么实现的。…
阅读更多...
[附源码]Python计算机毕业设计SSM基于java旅游信息分享网站（程序+LW)

[附源码]Python计算机毕业设计SSM基于java旅游信息分享网站（程序+LW)

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
汇编语言第2章—寄存器

汇编语言第2章—寄存器

8086CPU有14个寄存器&#xff0c;分别是&#xff1a;AX、BX、CX、DX、SI、DI、SP、BP、IP、CS、SS、DS、ES、PSW。2.1 通用寄存器 8086CPU的所有寄存器都是16位的&#xff0c;可以存放两个字节。AX、BX、CX、DX这4个寄存器通常用来存放一般性的数据&#xff0c;称为通用…
阅读更多...
【Spring】AOP记录日志

【Spring】AOP记录日志

我的aop记录日志&#xff0c;可以记录&#xff1a;【 操作类型、操作描述、参数、登录项目的用户ip】 当然记录什么靠你自己决定。 一.自定义一个注解 Target({ElementType.METHOD,ElementType.PARAMETER}) Retention(RetentionPolicy.RUNTIME) Documented public interface A…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023