二叉树的前序遍历,中序遍历,后序遍历以及层序遍历

二叉树的前序遍历

前序遍历(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;
	}

};