leetcode刷题 二叉树的迭代遍历以及层序遍历
二叉树的迭代遍历
前序遍历
/**
* 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<int> preorderTraversal(TreeNode* root) {
TreeNode * p = root;
stack<TreeNode *> st;
vector<int> result;
while(p || !st.empty()){
if(p == nullptr){
p = st.top();
st.pop();
p = p->right;
}
else{
result.push_back(p->val);
st.push(p);
p = p->left;
}
}
return result;
}
};
中序遍历
/**
* 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<int> inorderTraversal(TreeNode* root) {
stack<TreeNode *> st;
vector<int> result;
TreeNode * p = root;
while(p || !st.empty()){
if(p == nullptr){
p = st.top();
st.pop();
result.push_back(p->val);
p = p->right;
}
else{
st.push(p);
p = p->left;
}
}
return result;
}
};
后序遍历
/**
* 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<int> postorderTraversal(TreeNode* root) {
stack<TreeNode *> st;
vector<int> result;
TreeNode * p = root;
TreeNode * r = nullptr;
while(p || !st.empty()){
if(p == nullptr){
p = st.top();
if(p->right && r != p->right){
p = p->right;
}
else{
r = p;
result.push_back(p->val);
st.pop();
p = nullptr;
}
}
else{
st.push(p);
p = p->left;
}
}
return result;
}
};
二叉树的层序遍历
102.二叉树的层序遍历
示例1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
/**
* 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<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode *> que;
TreeNode * p = root;
vector<vector<int>> result;
if(p != nullptr)
que.push(p);
int size;
while(!que.empty()){
size = que.size();//得出每一层的结点数量
vector<int> vec;
for(int i = 0; i < size; ++i){//将每一层的结点放在同一个矢量中
p = que.front();
que.pop();
vec.push_back(p->val);
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
result.push_back(vec);
}
return result;
}
};
107.二叉树的层次遍历 II
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
自下而上的层序遍历将自上而下的层序遍历得到的结果逆置即可。即reverse(result.begin(), result.end());
199.二叉树的右视图
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
将每一层的最后一个结点放入结果即可
/**
* 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<int> rightSideView(TreeNode* root) {
vector<int> result;
TreeNode * p = root;
queue<TreeNode *> que;
if(p != nullptr)
que.push(p);
int size;
while(!que.empty()){
size = que.size();
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
result.push_back(p->val);
}
return result;
}
};
637.二叉树的层平均值
给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
/**
* 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<double> averageOfLevels(TreeNode* root) {
vector<double> result;
queue<TreeNode *> que;
TreeNode * p = root;
int size;
double sum;
if(p != nullptr)
que.push(p);
while(!que.empty()){
size = que.size();
sum = 0.0;
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
sum += p->val;
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
result.push_back(sum/size);
}
return result;
}
};
429.N叉树的层序遍历
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
例如，给定一个 3叉树 :
返回其层序遍历:
[ [1], [3,2,4], [5,6] ]
/*
// Definition for a Node.
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;
Node * p = root;
vector<vector<int>> result;
int size;
if(p != nullptr)
que.push(p);
while(!que.empty()){
size = que.size();
vector<int> vec;
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
vec.push_back(p->val);
for(vector<Node *>::iterator it = p->children.begin(); it != p->children.end(); ++it){
if(*it != nullptr)
que.push(*it);
}
}
result.push_back(vec);
}
return result;
}
};
515.在每个树行中找最大值
您需要在二叉树的每一行中找到最大的值。
/**
* 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<int> largestValues(TreeNode* root) {
queue<TreeNode *> que;
vector<int> result;
TreeNode * p = root;
int max;
int size;
if(p != nullptr)
que.push(p);
while(!que.empty()){
size = que.size();
max = INT_MIN;
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
if(max < p->val)
max = p->val;
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
result.push_back(max);
}
return result;
}
};
116.填充每个节点的下一个右侧节点指针
给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node* next;
Node() : val(0), left(NULL), right(NULL), next(NULL) {}
Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
Node(int _val, Node* _left, Node* _right, Node* _next)
: val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
Node* connect(Node* root) {
queue<Node *> que;
Node * p;
int size;
if(root != nullptr)
que.push(root);
while(!que.empty()){
p = nullptr;
size = que.size();
for(int i = 0; i < size; ++i){
if(p != nullptr)
p->next = que.front();
p = que.front();
que.pop();
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
p->next = nullptr;
}
return root;
}
};
117.填充每个节点的下一个右侧节点指针II
与116同样的解决方法，同样的代码。
104.二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
返回它的最大深度 3 。
/**
* 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:
int maxDepth(TreeNode* root) {
int depth = 0;
queue<TreeNode *> que;
TreeNode * p;
int size;
if(root != nullptr)
que.push(root);
while(!que.empty()){
size = que.size();
depth++;
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
}
return depth;
}
};
111.二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
输入：root = [3,9,20,null,null,15,7]
输出：2
/**
* 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:
int minDepth(TreeNode* root) {
queue<TreeNode *> que;
int depth = 0;
TreeNode * p;
int size;
if(root != nullptr)
que.push(root);
while(!que.empty()){
size = que.size();
depth++;
for(int i = 0; i < size; ++i){
p = que.front();
que.pop();
if(p->left == nullptr && p->right == nullptr)
return depth;
else{
if(p->left != nullptr)
que.push(p->left);
if(p->right != nullptr)
que.push(p->right);
}
}
}
return depth;
}
};
浙公网安备 33010602011771号