代码随想录算法训练营第14天|递归遍历非递归遍历

B七.七.七J

已于 2024-03-19 13:05:28 修改

阅读量336

点赞数 5

文章标签：算法数据结构

于 2024-03-19 13:04:54 首次发布

本文链接：https://blog.csdn.net/weixin_72346414/article/details/136836988

版权

本文介绍了如何使用递归和非递归方法遍历二叉树的前序、中序和后序，包括C++代码示例，以及理解后序遍历的特殊性。

摘要由CSDN通过智能技术生成

递归遍历

之前已经刷过二叉树的题目了，当时的我连觉得遍历都很难，现在已经觉得很简单啦！

前序

https://leetcode.cn/problems/binary-tree-preorder-traversal/description/

/**
 * 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 {
private:
        void pre(TreeNode*root,vector<int>&result)
        {
            if(root==NULL)
            return ;
            result.push_back(root->val);
            pre(root->left,result);
            pre(root->right,result);
        }
public:
    vector<int>preorderTraversal(TreeNode*root)
      {
         vector<int>result;
          pre(root,result);
          return result;
      }
};

中序

https://leetcode.cn/problems/binary-tree-inorder-traversal/submissions/513791955/

/**
 * 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:
    void in(TreeNode*root,vector<int>&result)
    {
        if(root==NULL)
        return;
        in(root->left,result);
        result.push_back(root->val);
        in(root->right,result);
    }
    vector<int>inorderTraversal(TreeNode*root)
    {
      vector<int>result;
      in(root,result);
      return result;
    }
};

后序

https://leetcode.cn/problems/binary-tree-postorder-traversal/

/**
 * 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:
    void post(TreeNode*root,vector<int>&result)
    {
        if(root==NULL)
        return;
        post(root->left,result);
        post(root->right,result);
        result.push_back(root->val);
    }
    vector<int>postorderTraversal(TreeNode*root)
    {
        vector<int>result;
        post(root,result);
        return result;
    }
};

非递归遍历

刚刚还在感叹递归简单，但是非递归我还是不会，还是得看视频哭哭。

前序

https://leetcode.cn/problems/binary-tree-preorder-traversal/submissions/513815764/

/**
 * 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 {
private:
        void pre(TreeNode*root,vector<int>&result)
        {
            if(root==NULL)
            return ;
            result.push_back(root->val);
            pre(root->left,result);
            pre(root->right,result);
        }
public:
    vector<int>preorderTraversal(TreeNode*root)
      {
        //  vector<int>result;
        //   pre(root,result);
        //   return result;
        stack<TreeNode*>s;
        vector<int>result;
        s.push(root);
        while(!s.empty())
        {
            TreeNode*temp=s.top();
            s.pop();
            if(temp)
            {
                result.push_back(temp->val);
                  s.push(temp->right);
                  s.push(temp->left);
            }
        }
        return result;
      }
};

中序

写起来还是磕磕绊绊的

https://leetcode.cn/problems/binary-tree-inorder-traversal/submissions/513823828/

/**
 * 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:
    void in(TreeNode*root,vector<int>&result)
    {
        if(root==NULL)
        return;
        in(root->left,result);
        result.push_back(root->val);
        in(root->right,result);
    }
    vector<int>inorderTraversal(TreeNode*root)
    {
    //   vector<int>result;
    //   in(root,result);
    //   return result;
        stack<TreeNode*>s;
        vector<int>result;
        TreeNode*temp=root;
        while(temp||!s.empty())
        {   if(temp)
            {
                s.push(temp);
                temp=temp->left;
            }
            else
            {
               temp=s.top();
               result.push_back(temp->val);
               s.pop();
               temp=temp->right;
            }
        }
        return result;
    }
};

后序

后序很神奇，因为后序是左右中，而前序是中左右，所以只需把前序代码中的s.push(temp->right)和s.push(temp->left)修改一下顺序，就变成了中右左，而把得到的中右左的结果再翻转一下就变成了左右中。

https://leetcode.cn/problems/binary-tree-postorder-traversal/description/

/**
 * 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:
    void post(TreeNode*root,vector<int>&result)
    {
        if(root==NULL)
        return;
        post(root->left,result);
        post(root->right,result);
        result.push_back(root->val);
    }
    vector<int>postorderTraversal(TreeNode*root)
    {
        // vector<int>result;
        // post(root,result);
        // return result;
        stack<TreeNode*>s;
        s.push(root);
        vector<int>result;
        while(!s.empty())
        {
            TreeNode*temp=s.top();
            s.pop();
            if(temp)
            {
                result.push_back(temp->val);
                s.push(temp->left);
                s.push(temp->right);
            }
        }
        reverse(result.begin(),result.end());
        return result;
    }
};