十道层序遍历题
102. 二叉树的层序遍历 - 力扣（LeetCode）
思路：使用队列queue来辅助解决这道题目。先把根节点放到队列中，然后每次循环开始都统计队列此时的长度size(注意是此时的长度)，将队列中的元素一一弹出，同时将被弹出的元素的左右孩子推入队列，当size为0时即为一层遍历完成
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> q;
vector<vector<int> > ans;
if(root == nullptr) {
return ans;
}
q.push(root);
while(!q.empty()) {
vector<int> atmp;
int qsize = q.size();
while(qsize--) {
TreeNode* tmp = q.front();
q.pop();
atmp.push_back(tmp->val);
if(tmp->left) q.push(tmp->left);
if(tmp->right) q.push(tmp->right);
}
ans.push_back(atmp);
atmp.clear();
}
return ans;
}
};标准答案
迭代法
//时间复杂度O(n),空间复杂度O(n)
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 - 力扣（LeetCode）
思路：层序遍历一次，最后将结果数组反转即可
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> ans;
queue<TreeNode*> que;
if(root == nullptr) {
return ans;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
vector<int> atmp;
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
atmp.push_back(tmp->val);
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
ans.push_back(atmp);
}
reverse(ans.begin(), ans.end());
return ans;
}
};199. 二叉树的右视图 - 力扣（LeetCode）
思路：进行层序遍历，每次遍历到每一层的最后一个就加入结果数组
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
queue<TreeNode*> que;
vector<int> ans;
if(root == nullptr) {
return ans;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
if(qsize == 0) {
ans.push_back(tmp->val);
}
}
}
return ans;
}
};637. 二叉树的层平均值 - 力扣（LeetCode）
思路：层序遍历二叉树，计算每一层的平均值
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
vector<double> ans;
queue<TreeNode*> que;
if(root == nullptr) {
return ans;
}
que.push(root);
while(!que.empty()) {
double ave = 0;
int qsize = que.size();
int cnt = qsize;
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
ave += tmp->val;
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
ans.push_back(ave / cnt);
}
return ans;
}
};429. N 叉树的层序遍历 - 力扣（LeetCode）
思路：和层序遍历思路一样，不过遍历的时候要将所有子树都加入队列
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
vector<vector<int> > ans;
queue<Node*> que;
if(root == nullptr) {
return ans;
}
que.push(root);
while(!que.empty()) {
vector<int> atmp;
int qsize = que.size();
while(qsize--) {
Node* tmp = que.front();
atmp.push_back(tmp->val);
que.pop();
int nsize = tmp->children.size();
for(int i = 0; i < nsize; ++i) {
if(tmp->children[i] != nullptr) {
que.push(tmp->children[i]);
}
}
}
ans.push_back(atmp);
}
return ans;
}
};515. 在每个树行中找最大值 - 力扣（LeetCode）
思路：层序遍历二叉树，找出每层的最大值即可
注意：数据可能是负的
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
vector<int> ans;
queue<TreeNode*> que;
if(root == nullptr) {
return ans;
}
que.push(root);
while(!que.empty()) {
long long mmax = -(2e10 + 10);
int qsize = que.size();
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
if(tmp->val > mmax) {
mmax = tmp->val;
}
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
ans.push_back(mmax);
}
return ans;
}
};116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
思路：层序遍历二叉树，如果遍历到的节点不是最后一个就指向下一个节点，否则指向NULL
注意：要注意判断的方法，当qsize == 0时说明是末尾
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if(root == NULL) {
return root;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
while(qsize--) {
Node* tmp = que.front();
que.pop();
if(!que.empty()) {
Node* tmp2 = que.front();
if(qsize == 0) {
tmp->next = NULL;
}
else {
tmp->next = tmp2;
}
}
else {
tmp->next = NULL;
}
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
}
return root;
}
};117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）
思路：和上道题目一模一样，直接复制粘贴代码就过了
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if(root == NULL) {
return root;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
while(qsize--) {
Node* tmp = que.front();
que.pop();
if(!que.empty()) {
Node* tmp2 = que.front();
if(qsize == 0) {
tmp->next = NULL;
}
else {
tmp->next = tmp2;
}
}
else {
tmp->next = NULL;
}
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
}
return root;
}
};104. 二叉树的最大深度 - 力扣（LeetCode）
思路：层序遍历二叉树，每遍历一层深度就加一
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*> q;
int ans = 0;
if(root == nullptr) {
return ans;
}
q.push(root);
while(!q.empty()) {
ans++;
int qsize = q.size();
while(qsize--) {
TreeNode* tmp = q.front();
q.pop();
if(tmp->left) q.push(tmp->left);
if(tmp->right) q.push(tmp->right);
}
}
return ans;
}
};111. 二叉树的最小深度 - 力扣（LeetCode）
思路：层序遍历二叉树，每遍历一层计数加一，如果遇到某一个节点没有左右子树则直接返回答案
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> q;
int ans = 0;
if(root == nullptr) {
return ans;
}
q.push(root);
while(!q.empty()) {
ans++;
int qsize = q.size();
while(qsize--) {
TreeNode* tmp = q.front();
q.pop();
int flag = 0;
if(tmp->left) {
q.push(tmp->left);
}
else {
flag++;
}
if(tmp->right) {
q.push(tmp->right);
}
else {
if(flag == 1) {
return ans;
}
}
}
}
return ans;
}
};226. 翻转二叉树 - 力扣（LeetCode）
思路:层序遍历二叉树，每次都将遍历到的节点的左右子树相互交换
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if(root == nullptr) {
return root;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
if(tmp->left && tmp->right) {
TreeNode* node = tmp->left;
tmp->left = tmp->right;
tmp->right = node;
}
else if(tmp->left == nullptr && tmp->right) {
tmp->left = tmp->right;
tmp->right = nullptr;
}
else if(tmp->left && tmp->right == nullptr) {
tmp->right = tmp->left;
tmp->left = nullptr;
}
if(tmp->left) {
que.push(tmp->left);
}
if(tmp->right) {
que.push(tmp->right);
}
}
}
return root;
}
};标准答案
递归法（前序遍历）
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root == NULL) return root;
swap(root->left, root->right); // 中
invertTree(root->left); // 左
invertTree(root->right); // 右
return root;
}
};递归法（中序遍历）
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root == NULL) return root;
invertTree(root->left); // 左
swap(root->left, root->right); // 中
invertTree(root->left); // 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
return root;
}
};迭代法：深度优先遍历（前序遍历）
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root == NULL) return root;
stack<TreeNode*> st;
st.push(root);
while(!st.empty()) {
TreeNode* node = st.top(); // 中
st.pop();
swap(node->left, node->right);
if(node->right) st.push(node->right); // 右
if(node->left) st.push(node->left); // 左
}
return root;
}
};迭代法：广度优先遍历（层序遍历）
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
swap(node->left, node->right); // 节点处理
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};迭代法（统一中序遍历）
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
stack<TreeNode*> st;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* node = st.top();
if (node != NULL) {
st.pop();
if (node->right) st.push(node->right); // 右
st.push(node); // 中
st.push(NULL);
if (node->left) st.push(node->left); // 左
} else {
st.pop();
node = st.top();
st.pop();
swap(node->left, node->right); // 节点处理逻辑
}
}
return root;
}
};101. 对称二叉树 - 力扣（LeetCode）
思路：层序遍历二叉树，得到序列以后逐层对比是否对称，如果全部对称则返回true，否则返回false
注意：遇到空节点要给一个填充值
我的AC代码
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
bool isSymmetric(TreeNode* root) {
vector<vector<int>> ans;
queue<TreeNode*> que;
if(root->left == nullptr && root->right == nullptr) {
return true;
}
que.push(root);
while(!que.empty()) {
int qsize = que.size();
vector<int> atmp;
while(qsize--) {
TreeNode* tmp = que.front();
que.pop();
if(tmp == nullptr) {
atmp.push_back(9999);
continue;
}
else {
atmp.push_back(tmp->val);
}
if(tmp->left) {
que.push(tmp->left);
}
else {
que.push(nullptr);
}
if(tmp->right) {
que.push(tmp->right);
}
else {
que.push(nullptr);
}
}
ans.push_back(atmp);
}
for(auto a : ans) {
int asize = a.size();
int left = 0;
int right = asize - 1;
while(left < right) {
if(a[left] != a[right]) {
return false;
}
left++;
right--;
}
}
return true;
}
};标准答案
递归法
//时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
bool compare(TreeNode* left, TreeNode* right) {
// 首先排除空节点的情况
if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
// 排除了空节点，再排除数值不相同的情况
else if (left->val != right->val) return false;
// 此时就是：左右节点都不为空，且数值相同的情况
// 此时才做递归，做下一层的判断
bool outside = compare(left->left, right->right); // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left); // 左子树：右、 右子树：左
bool isSame = outside && inside; // 左子树：中、 右子树：中 （逻辑处理）
return isSame;
}
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
return compare(root->left, root->right);
}
};迭代法（使用队列）
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
queue<TreeNode*> que;
que.push(root->left); // 将左子树头结点加入队列
que.push(root->right); // 将右子树头结点加入队列
while (!que.empty()) { // 接下来就要判断这两个树是否相互翻转
TreeNode* leftNode = que.front(); que.pop();
TreeNode* rightNode = que.front(); que.pop();
if (!leftNode && !rightNode) { // 左节点为空、右节点为空，此时说明是对称的
continue;
}
// 左右一个节点不为空，或者都不为空但数值不相同，返回false
if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
return false;
}
que.push(leftNode->left); // 加入左节点左孩子
que.push(rightNode->right); // 加入右节点右孩子
que.push(leftNode->right); // 加入左节点右孩子
que.push(rightNode->left); // 加入右节点左孩子
}
return true;
}
};迭代法（使用栈）
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
stack<TreeNode*> st; // 这里改成了栈
st.push(root->left);
st.push(root->right);
while (!st.empty()) {
TreeNode* leftNode = st.top(); st.pop();
TreeNode* rightNode = st.top(); st.pop();
if (!leftNode && !rightNode) {
continue;
}
if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
return false;
}
st.push(leftNode->left);
st.push(rightNode->right);
st.push(leftNode->right);
st.push(rightNode->left);
}
return true;
}
};
Comments NOTHING