数据结构：树的遍历递归版本与非递归版本实现

---

前言

这篇文章记录笔者学习树的递归与非递归版本进行遍历的实现

一、前序遍历

递归版本

树的前序遍历遍历的递归版本
我们依托根节点->左节点->右节点的方式递归

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> ans;
    vector<int> preorderTraversal(TreeNode* root) {
        dfs(root);
        return ans;
    }
    
    void dfs(TreeNode* root){
        if(root==nullptr) 
            return;
        ans.push_back(root->val);
        dfs(root->left);
        dfs(root->right);
    }
};

非递归版本

前序遍历的非递归版本，我们可以借助栈的数据结构进行实现，注意的是，在root节点入栈弹出后，我们要先把root节点的右节点压入栈，再将左节点压入栈，这样在弹出时，我们优先遇到的是左节点而不是右节点

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    
    //非递归版本
    vector<int> res;
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> q1;
        if (root==nullptr) return res;
        if (root!=nullptr){
            q1.push(root);
        }
        while(!q1.empty()){
            TreeNode* p=q1.top();
            q1.pop();
            if (p!=nullptr){
               res.push_back(p->val);
            }
            if(p->right!=nullptr){
                q1.push(p->right);
            }
            if(p->left!=nullptr){
                q1.push(p->left);
            }
        }
        return res;
    }
};

二、中序遍历

1.递归版本

同前序遍历
代码如下（示例）：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }
    void dfs(TreeNode* root){
        if(root==nullptr) return;
        dfs(root->left);
        res.push_back(root->val);
        dfs(root->right);
    }
};

2.非递归版本

与前序遍历相似，仍然是利用一个栈的结构
先不断地向左节点移动，将左节点压入栈，当遇到空节点时返回，将返回的节点依次加入答案列表，如此反复

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    
    //非递归版本
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* t) {
        stack<TreeNode*> q;
        while(q.size()!=0 || t){
            if(t!=nullptr){
                q.push(t);
                t=t->left;
            }else{
                t=q.top();
                q.pop();
                res.push_back(t->val);
                t=t->right;
            }
        }
        return res;
    }
};

三、后序遍历

1.递归版本

递归版本和前序、中序类似，调整一下代码顺序即可

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> res;
    vector<int> postorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }
    void dfs(TreeNode* root){
        if(root==nullptr) return;
        dfs(root->left);
        dfs(root->right);
        res.push_back(root->val);
    }
};

2.非递归版本

后续遍历的非递归版本，关键在于要输出的根节点，需要是第二遍走到，而不是第一次遇到就将其加入答案中
顺序：左节点->右节点->根节点

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> res;
    
    vector<int> postorderTraversal(TreeNode* t) {
        stack<TreeNode*> q1;
        unordered_map<TreeNode*,int> treeHash;
        while(t!=nullptr||q1.size()!=0){
            if(t!=nullptr){
                q1.push(t);
                treeHash[t]=1;
                t=t->left;
            }else{
                t=q1.top();
                if(treeHash[t]==2){
                    q1.pop();
                    res.push_back(t->val);
                    t=nullptr;//开始回退往上走
                }else{
                    treeHash[t]=2;
                    t=t->right;
                }
            }
        }
        return res;
    }
    
};

总结

以上是树的遍历递归版本与非递归版本的实现