Leetcode144. 二叉树的前序遍历
题目链接:144. 二叉树的前序遍历
C++:
方法一:递归
/**
* 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:
void qianbianli(TreeNode *cur, vector<int> &result){
if(cur == nullptr) return;
result.push_back(cur->val);
qianbianli(cur->left, result);
qianbianli(cur->right, result);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
qianbianli(root, result);
return result;
}
};
方法二:迭代法,用栈实现前序遍历
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
//迭代法前序遍历
vector<int> result;
stack<TreeNode*> st;
st.push(root);
while(!st.empty())
{
TreeNode* cur = st.top();
st.pop();
if(cur == nullptr)
continue;
result.push_back(cur->val);
st.push(cur->right);
st.push(cur->left);
}
return result;
}
};
统一迭代:
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if(root != nullptr) st.push(root);
while(!st.empty())
{
TreeNode *node = st.top();
if(node != nullptr)
{
st.pop();
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
st.push(node);
st.push(nullptr);
}
else
{
st.pop();
node = st.top();
st.pop();
result.push_back(node->val);
}
}
return result;
}
};
Python:
递归法:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def qianbianli(self, cur, result):
if cur == None:
return
result.append(cur.val)
self.qianbianli(cur.left, result)
self.qianbianli(cur.right, result)
def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
self.qianbianli(root, result)
return result
迭代法:
class Solution:
def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
stack = [root]
while stack:
cur = stack.pop()
if cur == None:
continue
result.append(cur.val)
stack.append(cur.right)
stack.append(cur.left)
return result
Leetcode145.二叉树的后序遍历
题目链接:145. 二叉树的后序遍历
C++:
递归法:
class Solution {
public:
void houbianli(TreeNode *cur, vector<int> &result){
if(cur == nullptr) return;
houbianli(cur->left, result);
houbianli(cur->right, result);
result.push_back(cur->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
houbianli(root, result);
return result;
}
};
迭代法:
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
st.push(root);
while(!st.empty())
{
TreeNode *cur = st.top();
st.pop();
if(cur == nullptr)
continue;
result.push_back(cur->val);
st.push(cur->left);
st.push(cur->right);
}
reverse(result.begin(), result.end());
return result;
}
};
统一迭代:
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if(root != nullptr) st.push(root);
while(!st.empty())
{
TreeNode *node = st.top();
if(node != nullptr)
{
st.pop();
st.push(node); //中
st.push(nullptr);
if(node->right) st.push(node->right); //右
if(node->left) st.push(node->left); //左
}
else
{
st.pop();
node = st.top();
st.pop();
result.push_back(node->val);
}
}
return result;
}
};
Python:
递归法:
class Solution:
def houbianli(self, cur, result):
if cur == None:
return
self.houbianli(cur.left, result)
self.houbianli(cur.right, result)
result.append(cur.val
)
def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
self.houbianli(root, result)
return result
迭代法:
class Solution:
def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
stack = [root]
while stack:
cur = stack.pop()
if cur == None:
continue
result.append(cur.val)
stack.append(cur.left)
stack.append(cur.right)
return result[::-1]
Leetcode94.二叉树的中序遍历
题目链接:94. 二叉树的中序遍历
C++:
递归法:
class Solution {
public:
void zhongbianli(TreeNode* cur, vector<int> &result){
if(cur == nullptr)
return;
zhongbianli(cur->left, result);
result.push_back(cur->val);
zhongbianli(cur->right, result);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
zhongbianli(root, result);
return result;
}
};
迭代法:
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
TreeNode *cur = root;
while(!st.empty() || cur != nullptr)
{
if(cur != nullptr)
{
st.push(cur);
cur = cur->left;
}
else
{
cur = st.top();
st.pop();
result.push_back(cur->val);
cur = cur->right;
}
}
return result;
}
};
统一迭代:
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if(root != nullptr) st.push(root);
while(!st.empty())
{
TreeNode *node = st.top();
if(node != nullptr)
{
st.pop();
if(node->right) st.push(node->right);
st.push(node);
st.push(nullptr);
if(node->left) st.push(node->left);
}
else
{
st.pop();
node = st.top();
st.pop();
result.push_back(node->val);
}
}
return result;
}
};
Python:
递归法:
class Solution:
def zhongbianli(self, cur, result):
if cur == None:
return
self.zhongbianli(cur.left, result)
result.append(cur.val)
self.zhongbianli(cur.right, result)
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
self.zhongbianli(root, result)
return result
迭代法:
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
result = []
st = []
cur = root
while cur != None or st:
if cur != None:
st.append(cur)
cur = cur.left
else:
cur = st.pop()
result.append(cur.val)
cur = cur.right
return result
Leetcode102.二叉树的层序遍历
题目链接:102. 二叉树的层序遍历
C++:
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
queue<TreeNode*> que;
if(root != nullptr) que.push(root);
while(!que.empty())
{
int size = que.size();
vector<int> vec;
while(size--)
{
TreeNode* cur = que.front();
que.pop();
vec.push_back(cur->val);
if(cur->left) que.push(cur->left);
if(cur->right) que.push(cur->right);
}
result.push_back(vec);
}
return result;
}
};
Python:
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
result = []
que = deque()
if root:
que.append(root)
while que:
vec = []
size = len(que)
for i in range(size):
cur = que.popleft()
vec.append(cur.val)
if cur.left:
que.append(cur.left)
if cur.right:
que.append(cur.right)
result.append(vec)
return result