代码随想录第14天|二叉树| ● 理论基础 ● 递归遍历 ● 迭代遍历 ● 统一迭代

理论基础

树，是一种基础的数据结构。一棵树的子节点数量最大为2（度为2）的树称为二叉树。

//二叉树的定义
struct TreeNode{
    int val;//数据
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x):val(x),left(nullptr),right(nullptr){}//初始化
};

递归遍历

二叉树的非层次遍历包括前序遍历，中序遍历，后序遍历。

class Solution{
public:
    //前序遍历
	void preOrder(TreeeNode* root){
        if(root==nullptr)	return ;
        //结点操作——比如保存
        ans.push_back(root->val);
        preOrder(root->left);
        preOrder(root->right);
	}
    
    //中序遍历
    void inOrder(TreeNode* root){
        if(root==nullptr)	return ;
        preOrder(root->left);
        
        //结点操作——比如保存
        ans.push_back(root->val);
        preOrder(root->right);
    }
    
    //后序遍历
    void postOrder(TreeNode* root){
       	if(root==nullptr)	return ;
        postOrder(root->left);
        postOrder(root->right);
         //结点操作——比如保存
        ans.push_back(root->val);
    }
    vector<int> traversal(TreeNode*Node){        
        vector<int>ans;//保存结果
        preOrder(Node);
        inOrder(Node);
        postOrder(Node);
    }
};

迭代遍历

二叉树的非层次遍历的迭代写法，基于栈实现（层次遍历基于队列实现）

class Solution{
public:
    //前序迭代
    vector<int> preOrder(TreeNode *root){
        stack<TreeNode*>st;
        vector<int>ans;
        if(root==nullptr)	return ans;
        st.push(root);
        while(!st.empty()){
            TreeNode*node=st.pop();
            st.pop();
            ans.push_back(node->val);
            if(node->left)	st.push(node->left);
            if(node->right)	st.push(node->right);
        }
        return result;
    }
    
    
    //中序遍历
    vector<int> inOrder(TreeNode *root){
        stack<TreeNode*>st;
        vector<int>ans;
        if(root==nullptr)	return ans;
        TreeNode* cur=root;
        while(cur||!st.empty()){//中左右——先找左子树的根节点
            if(cur){
                st.push(cur);
                cur=cur->left;//左子树的根节点进队
            }else{
                cur=st.pop();
                st.pop();
                ans.push_back(cur->val);//保存左
                cutr=cur->right;//保存右
            }            
        }
        return ans;
    }
    
    //后序遍历 
    vector<int> postOrder(TreeNode *root){
        stack<TreeNode*>st;
        vector<int>ans;
        if(root==nullptr)	return ans;
        st.push(root);
        while(!st.empty()){
            TreeNode*node=st.pop();
            st.pop();
            ans.push_back(node->val);
            if(node->left)	st.push(node->left);
            if(node->right)	st.push(node->right);
        }
        reverse(ans.begin(),ans.end());
        return result;
    }
};

统一迭代

迭代写法的统一模板

class Solution{
public:
    //中序
    vector<int> inOrder(TreeNode* root){
        vector<int>ans;
        stack<TreeNode*>st;
        if(root==nullptr)	return ans;
        st.push(root);
        while(!st.empty()){
            TreeNode* node=st.pop();
            if(node){
                st.pop();
                if(node->right)	st.push(node->right);
                st.push(node);
                st.push(null);
            }else{//遇到空节点，直接处理下一节点
                st.pop();
                node=st.pop();//处理下一个
                st.pop();
                ans.push_back(node->val);
            }
        }
        return ans;
    }
    
    //前序
     vector<int> preOrder(TreeNode* root){
        vector<int>ans;
        stack<TreeNode*>st;
        if(root==nullptr)	return ans;
        st.push(root);
        while(!st.empty()){
            TreeNode* node=st.pop();
            if(node){
                st.pop();
                if(node->right)	st.push(node->right);
                if(node->left)	st.push(node->left);
                st.push(node);
                st.push(null);
            }else{//遇到空节点，直接处理下一节点
                st.pop();
                node=st.pop();//处理下一个
                st.pop();
                ans.push_back(node->val);
            }
        }
         return ans;
    }
    
    //后序
     vector<int> postOrder(TreeNode* root){
        vector<int>ans;
        stack<TreeNode*>st;
        if(root==nullptr)	return ans;
        st.push(root);
        while(!st.empty()){
            TreeNode* node=st.pop();
            if(node){
                st.pop();
                st.push(node);
                st.push(null);
                
                if(node->right)	st.push(node->right);
                if(node->left)	st.push(node->left);                
            }else{//遇到空节点，直接处理下一节点
                st.pop();
                node=st.pop();//处理下一个
                st.pop();
                ans.push_back(node->val);
            }
        }
         return ans;
    }
    
};