二叉树的前序遍历
前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
oj链接: https://leetcode-cn.com/problems/binary-tree-preorder-traversal/submissions/
递归实现:
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> v;
PushVal(v, root);
return v;
}
private:
void PushVal(vector<int> &v, TreeNode* root){
if(root == nullptr){ //空节点就退出
return;
}
v.push_back(root->val); //先将节点值保存起来
PushVal(v, root->left); //进入左节点
PushVal(v, root->right);//进入右节点
}
};
非递归实现:
//借助栈完成
//1. 将当前节点的val保存
//2. 如果它有右孩子就将右孩子入栈
//3. 如果它有左孩子就访问左孩子,如果没有就访问栈顶
//4. 没有孩子,并且栈空时跳出循环
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> v;
v.clear();
if(root == nullptr){ //空的头节点就返回空数组
return v;
}
v.push_back(root->val); //先保存根节点的值
stack<TreeNode*> st; //借助栈来完成
while(root)
{
if(root->right){ //如果它的右孩子存在就将右孩子入栈
st.push(root->right);
}
if(root->left){ //如果它的左孩子存在就访问左孩子
root = root->left;
v.push_back(root->val);
}else if(!st.empty()){ //如果左孩子不存在但是栈不为空就访问栈顶节点
root = st.top();
v.push_back(root->val);
st.pop();
}else{ //如果左孩子不存在并且栈为空就退出
break;
}
}
return v;
}
};
二叉树的中序遍历
oj链接: https://leetcode-cn.com/problems/binary-tree-inorder-traversal/submissions/
递归实现:
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> v;
PushVal(v, root);
return v;
}
private:
void PushVal(vector<int> &v, TreeNode* root){
if(root == nullptr){
return;
}
PushVal(v, root->left); //先访问左节点
v.push_back(root->val); //保存val
PushVal(v, root->right); //在访问右节点
}
};
非递归实现:
//1. 将所有的左孩子入栈
//2. 取出栈顶节点,访问其右孩子,如果有右孩子,重复操作1
//如果没有右孩子重复操作2
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> v;
if(root == nullptr){ //root为空就返回空数组
return v;
}
stack<TreeNode*> st; //借助栈实现
while(root || !st.empty()) //root或者栈其中一个不为空时,继续循环
{
for(; root; root = root->left) //先将所有的左孩子入栈
{
st.push(root);
}
root = st.top(); //取出栈顶节点
v.push_back(root->val); //保存val
st.pop(); //出栈
root = root->right; //访问栈顶节点的右孩子并进入下一个循环
}
return v;
}
};
二叉树的后序遍历
oj链接: https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
递归实现:
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> v;
PushVal(v, root);
return v;
}
private:
void PushVal(vector<int> &v, TreeNode* root)
{
if(root == nullptr){
return;
}
PushVal(v, root->left); //先访问左孩子
PushVal(v, root->right); //在访问右孩子
v.push_back(root->val); //最后保存val
}
};
非递归实现:
//借用两个栈来实现
//1. 将根节点入栈1,并进入循环
//2. 访问栈1的栈顶元素,并将其pop
//3. 如果其有左孩子将其左孩子入栈1,
//4. 如果其有右孩子将其右孩子入栈1,
//5. 将该节点入栈2;
//最后栈2的出栈顺序为后序遍历
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> v;
if (root == nullptr) {
return v;
}
stack<TreeNode*> st1; //栈1
stack<TreeNode*> st2; //栈2
st1.push(root); //根节点入栈1
while (!st1.empty()) //栈1空的时候退出循环
{
root = st1.top(); //获取栈顶元素
st1.pop(); //pop
if (root->left) { //有左孩子左孩子入栈
st1.push(root->left);
}
if (root->right) { //有右孩子右孩子入栈
st1.push(root->right);
}
st2.push(root);
}
while (!st2.empty()) //栈2出栈并保存val
{
TreeNode* tmp = st2.top();
v.push_back(tmp->val);
st2.pop();
}
return v;
}
};
二叉树的层序遍历
//借助队列完成
//1. 根节点入队
//2. 进入循环, 取队首元素保存其值
//3. 如果有左孩子,左孩子入队
//4. 如果有右孩子,右孩子入队
class Solution
{
public:
vector<int> Traversal(TreeNode* root)
{
vector<int> v;
if (root == nullptr) {
return v;
}
queue<TreeNode*> qu;
qu.push(root);
while (!qu.empty())
{
root = qu.front();
qu.pop();
v.push_back(root->val);
if (root->left) {
qu.push(root->left);
}
if (root->right) {
qu.push(root->right);
}
}
return v;
}
};