二叉树的遍历

前序遍历

1.迭代：

/**
 * 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) {
vector<int>ret;
stack<TreeNode*>stk;
TreeNode *node=root;
while(stk.empty()!=1||node!=nullptr){
    while(node!=nullptr){
     ret.push_back(node->val);
     stk.push(node);
     node=node->left;
    }
    node=stk.top();
    stk.pop();
    node=node->right;
}
return ret;
    }
};

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:
    vector<int> preorderTraversal(TreeNode* root) {
    vector<int>ret;
    preorder(root,ret);
    return ret;
    }
    void preorder(TreeNode* root,vector<int>&ret){//双向传递
    if(root==nullptr){
        return ;
    }
    ret.push_back(root->val);
    preorder(root->left,ret);
    preorder(root->right,ret);
    }
};

3.Morris 遍历 利用了中序遍历的思想，做完中序再回头

中序遍历

1.递归

/**
 * 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) {
        vector<int>res;
        inorder(root,res);
        return res;
    }
    void inorder(TreeNode*root,vector<int>&res){
        if(root==nullptr){
            return ;
        }
        inorder(root->left,res);
        res.push_back(root->val);
        inorder(root->right,res);

    }
};

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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>res;
        stack<TreeNode*>stk;
        TreeNode*node=root;
        while(!stk.empty()||node!=nullptr){
            while(node!=nullptr){
                stk.push(node);
                node=node->left;
            
            }
            
            //res.push_back(node->val);
            node=stk.top();
            res.push_back(node->val);
            stk.pop();
            node=node->right;

        }
        return res;
    }
};

后序遍历

1.递归（思路类似，只是存储顺序改变

/**
 * 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) {
        vector<int>res;
        postorder(root,res);
        return res;
    }
    void postorder(TreeNode* root,vector<int>&res){
        if(root==nullptr)return ;
        postorder(root->left,res);
        postorder(root->right,res);
        res.push_back(root->val);
    }
};

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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int>res;
        if(root==nullptr)return res;
        TreeNode*prev=nullptr;
        stack<TreeNode*>stk;
        while(!stk.empty()||root!=nullptr){
            while(root!=nullptr){
                stk.push(root);
                root=root->left;
            }
            root=stk.top();
            stk.pop();
            if(root->right!=nullptr&&root->right!=prev){//注意条件
                stk.push(root);
                root=root->right;
            }
            else{
                res.push_back(root->val);
                prev=root;
                root=nullptr;
            }
        }
        return res;
    }
   
};

层序遍历

DFS（深度优先搜索）和 BFS（广度优先搜索）

/**
 * 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*>qque;
        vector<vector<int>>ret;
        qque.push(root);
        TreeNode*tmp=root;
        while(!qque.empty()){
           // vector<int>r;
            ret.push_back(vector<int>());//加一行
            cout<<qque.size()<<endl;
            for(int i=0;i<qque.size();i++){
                tmp=qque.front();qque.pop();
                ret.back().push_back(tmp->val);//下一行的加入元素
                if(tmp->left!=nullptr)qque.push(tmp->left);
                if(tmp->right!=nullptr)qque.push(tmp->right);
            }
           // ret.push_back(r);
        }
        return ret;
    }
};

    string serialize(TreeNode* root) {
        string res;
        dfs(root,res);
        return res;
    }

    void dfs(TreeNode*root,string res){
        if(root==nullptr){
            res=res+"#,";
        }
        else{
            res+=res+to_string(root->val);
            dfs(root->left);
            dfs(root->right);
        }