Day 14 理论基础递归遍历迭代遍历统一迭代

Salinoia

已于 2024-04-06 23:04:22 修改

阅读量298

点赞数 5

分类专栏：代码随想录训练营文章标签：算法

于 2024-04-02 21:24:19 首次发布

本文链接：https://blog.csdn.net/qq_46025584/article/details/137291298

版权

代码随想录训练营专栏收录该内容

53 篇文章 0 订阅

订阅专栏

二叉树理论基础

一入递归深似海，从此offer是路人；

二叉树的种类

满二叉树：

节点全满，2^k-1个节点；

完全二叉树：

除了底层以外其他层都是满的，且底部从左到右一定是连续的，满二叉树一定是完全二叉数；刚刚讲过优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系；

二叉搜索树：

若左子树不为空，则左边所有的子节点都小于根部节点；

若右子树不为空，右边所有的子节点都大于根部节点；

同样的规律适用于所有子树；

二叉搜索树只对元素顺序有要求，对二叉树结构无要求；

平衡二叉搜索树:

左子树和右子树的高度差不超过一的二叉搜索树；

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是log n；

unordered_map、unordered_set底层实现则是哈希表；（了解容器底层实现机制）

二叉树的存储方式

链式存储：

经典方法，节点+左右指针：

线性存储：

如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2；

虽然基本没用过，但是数组确实也可以保存二叉树。

二叉树的遍历

二叉树主要有两种遍历方式：

深度优先遍历：先往深走，遇到叶子节点再往回走；熟知的前中后序遍历都是深度优先搜索（递归法和迭代法均可）；

广度优先遍历：一层一层的去遍历（图论里则是一圈一圈去遍历）；层序搜索就是广度优先搜索（迭代法）；

理论上来说，递归能理解的问题，迭代都可以解决；

接下来就是老生常谈的东西了：

前序遍历：中左右；中序遍历：左中右；后序遍历：左右中；

二叉树的定义

struct TreeNode{
    int val;
    TreeNode* Left;
    TreeNode* Right;
    TreeNode(int x):val(x),Left(NULL),Right(NULL){};
};

递归遍历(144 145 94)

如何写出正确的递归代码：

1.确定递归函数的参数和返回值:

确定哪些参数是递归的过程中需要处理的（如果情况复杂可以先考虑过程，再逐渐写入参数），那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型;

2.确定终止条件:

写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对；操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出;

3.确定单层递归的逻辑：

确定每一层递归需要处理的信息；在这里也就会重复调用自己来实现递归的过程。

接下来尝试实现前序遍历：

//前序遍历：中左右
struct TreeNode{
    int val;
    TreeNode* Left;
    TreeNode* Right;
    TreeNode(int x):val(x),Left(nullptr),Right(nullptr){};
};
void travalsal(TreeNode* cur, vector<int>& res){//传入二叉树根节点和存储返回元素的数组
   if(cur == NULL)	return;//终止条件
   res.push(cur->val);//中
   travalsal(cur->Left.val);//左
   travalsal(cur->Right.val);//右
};

中序后序就不用写了，中左右改为左中右和左右中即可；

虽然这个递归过程很简单，但是一定要学会如何写递归代码，不要凭感觉写！

力扣94题（中序遍历）代码如下：

/**
 * 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 travalsal(TreeNode* cur, vector<int>& res){//传入二叉树根节点和存储返回元素的数组
        if(cur == NULL)	return;//终止条件
        travalsal(cur->left,res);//左
        res.push_back(cur->val);//中
        travalsal(cur->right,res);//右
    };
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        travalsal(root,res);
        return res;
    }
};

力扣144题（前序遍历）代码如下：

/**
 * 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 travalsal(TreeNode* cur, vector<int>& res){//传入二叉树根节点和存储返回元素的数组
        if(cur == NULL)	return;//终止条件
        res.push_back(cur->val);//中
        travalsal(cur->left,res);//左
        travalsal(cur->right,res);//右
    };
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        travalsal(root,res);
        return res;
    }
};

力扣145题（后序遍历）代码如下：

/**
 * 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 travalsal(TreeNode* cur, vector<int>& res){//传入二叉树根节点和存储返回元素的数组
        if(cur == NULL)	return;//终止条件
        travalsal(cur->left,res);//左
        travalsal(cur->right,res);//右
        res.push_back(cur->val);//中
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        travalsal(root,res);
        return res;
    }
};

迭代遍历

首先搞清楚迭代是通过栈这种数据结构实现的；递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因；

那么用迭代法实现前序遍历的流程就如下图所示，要实现中左右，我们入栈的顺序应该是中右左，这样出栈的顺序才是中左右：

看图很好懂吧，写一下？

/**
 * 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){//返回的是前序遍历的元素，所以返回值为数组
        stack<TreeNode*> st;
        vector<int> res;
        if(root == NULL) return res;
        st.push(root);//将根节点push进去，即实现根节点的“中”先进去
        while(!(st.empty())){
            TreeNode* node = st.top();
            st.pop();
            if(node != NULL)	res.push_back(node->val);
            else continue;
            if(node->right)	st.push(node->right);//右子树进栈
            if(node->left)	st.push(node->left);//左子树进栈
        }
        return res;
    };
};

至于后序遍历，只需将左右子树进栈顺序换一下，这样入栈顺序为中左右，然后将得到的数组reverse，即得到左右中即后序遍历的数组；

代码如下：

/**
 * 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){//返回的是前序遍历的元素，所以返回值为数组
        stack<TreeNode*> st;
        vector<int> res;
        if(root == NULL) return res;
        st.push(root);//将根节点push进去，即实现根节点的“中”先进去
        while(!(st.empty())){
            TreeNode* node = st.top();
            st.pop();
            if(node != NULL)	res.push_back(node->val);
            else continue;
            if(node->left)	st.push(node->left);//左子树进栈
            if(node->right)	st.push(node->right);//右子树进栈
        }
        reverse(res.begin(),res.end());
        return res;
    };
};

那么中序呢，左中右？显而易见，这种逻辑下，中序是无法实现的，因为访问二叉树一定是先访问头节点，也就是遍历入栈的顺序都是头节点先处理的，这种逻辑下无论怎么处理也无法将根结点放在数组中间，因为访问元素和处理元素的顺序不一致；

此时可以利用一个指针来遍历二叉树里的所有元素，用栈记录所有遍历过的节点，代码如下：

/**
 * 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){//返回的是前序遍历的元素，所以返回值为数组
        stack<TreeNode*> st;
        vector<int> res;
        TreeNode* cur = root;
        while(cur != NULL || !(st.empty())){
            if(cur){//无论是判断cur->left还是cur->right是否为空，都可以用cur来实现，即左右移动均通过一个语句实现
                st.push(cur);//记录指针访问过的元素
                cur = cur->left;//左
            }
            else{
                cur = st.top();
                st.pop();
                res.push_back(cur->val);//中
                cur = cur->right;//右
            }
        }
        return res;
    };
};

统一迭代遍历

在上述的写法中，我们明显可以发现，这里使用的迭代法并不是统一的；

最显然的问题就是中序遍历面临的问题：无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况；

那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记；

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记；这种方法也可以叫做标记法；

具体操作过程如下图所示：

中序遍历代码如下：（实现过程中用NULL来记录中节点的位置）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

那么前序遍历就是这样：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                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.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

同理，后序遍历就是这样：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                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.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};