数据结构之二叉树的遍历---递归和迭代

1.递归法

二叉树天然符合递归，因此二叉树的递归算法特别简单

在写递归算法时应该分为系统的三步走

1）首先明确递归时明确需要处理的数据返回类型

2）一定要明确何时停止递归，否则无限递归下去必然导致栈溢出

3）确定单层递归的处理逻辑

leetcode题目

144.二叉树的前序遍历

94.二叉树的中序遍历

145.二叉树的后续遍历

前序遍历

class Solution {
public:
    void recursion(TreeNode* root,vector<int>& res)
    {
       if(root == NULL)//明确递归停止的条件
       {
           return;
       }
       res.push_back(root->val);//中节点
       recursion(root->left,res);//左节点
       recursion(rooy->right,res);//右节点
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> temp;
        recursion(root,temp);
        return temp;
    }
};

中序遍历和后序遍历仅仅需要改变单层递归的逻辑

中序遍历

class Solution {
public:
    void recursion(TreeNode* root,vector<int>& res)
    {
       if(root == NULL)//明确递归停止的条件
       {
           return;
       }     
       recursion(root->left,res);//左节点
       res.push_back(root->val);//中节点
       recursion(rooy->right,res);//右节点
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> temp;
        recursion(root,temp);
        return temp;
    }
};

后序遍历

class Solution {
public:
    void recursion(TreeNode* root,vector<int>& res)
    {
       if(root == NULL)//明确递归停止的条件
       {
           return;
       }     
       recursion(root->left,res);//左节点      
       recursion(rooy->right,res);//右节点
       res.push_back(root->val);//中节点
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> temp;
        recursion(root,temp);
        return temp;
    }
};

2.迭代法

迭代法主要是手工使用栈来进行二叉树的遍历

前序遍历：

先将中节点入栈，取栈顶元素放入结果数组内，再进行出栈操作，再依次将右节点左节点入栈，只要栈内数据不为空便循环此操作，直到完成遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*>stack1;
        vector<int> temp;

        if(root == NULL)
        {
            return temp;
        }
        stack1.push(root);
        while(!stack1.empty())
        {
            TreeNode* node = stack1.top();
            stack1.pop();
            temp.push_back(node->val);

            if(node->right)
            stack1.push(node->right);
            if(node->left)
            stack1.push(node->left);
        }
        return temp;
    }
};

中序遍历：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*>stack1;
        vector<int>result;

        TreeNode* cur = root;
        while(cur != NULL || !stack1.empty())
        {
            if(cur != NULL)
            {
                stack1.push(cur);
                cur = cur -> left;
            }
            else
            {
                cur = stack1.top();
                stack1.pop();
                result.push_back(cur -> val);

                cur = cur -> right;
            }
        }
        return result;
    }
};

后序遍历:

后序迭代遍历需要将先序稍微修改便可达到后序遍历的效果

先序遍历 ->(处理左右入栈顺序)中右左->(反转result数组)后序遍历(左右中)

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) 
    {
        stack<TreeNode*> stack1;
        vector<int> result;

        if(root == NULL)
        {
            return result;
        }
        stack1.push(root);
        while(!stack1.empty())
        {
            TreeNode* node = stack1.top();
            stack1.pop();
            result.push_back(node->val);

            
            if(node->left)
            {
                stack1.push(node->left);
            }
            if(node->right)
            {
                stack1.push(node->right);
            }
        }
        //反转数组 双指针法
        int pointer1 = 0;
        int pointer2 = result.size()-1;
        while(pointer1 <= pointer2)
        {
           int temp = result[pointer1];
           result[pointer1] = result[pointer2];
           result[pointer2] = temp;
        
           pointer1++;
           pointer2--;
        }
        return result;
    }
};