代码随想录算法训练营第十一天 | 二叉树基础

二叉树的基本概念

存储方式，链表存储或者数组存储

但一般用链表存储

定义结点

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二叉树的递归遍历

二叉树的迭代遍历（非递归）方法

非递归的迭代方法，在实现前中后序遍历时不能使用同一个方法

前序是最简单的

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                       // 中
            st.pop();
            result.push_back(node->val);
            if (node->right) st.push(node->right);           // 右（空节点不入栈）
            if (node->left) st.push(node->left);             // 左（空节点不入栈）
        }
        return result;
    }
};

中序遍历这里，当cur为null时，说明已遍历到了最左的结点，返回原来的中间结点，即st.top()
cur这里是作为指针出现的，来解决当前遍历到的点与加入result中不一样的情况

/**
 * 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> result;
        stack<TreeNode*> st;
        TreeNode*cur=root;
        while(cur!=NULL||!st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur=cur->left;
            }
            else{
                cur=st.top();
                st.pop();
                result.push_back(cur->val);
                cur=cur->right;
            }
        }
        return result;
    }
};```

==后序遍历这个思路巧妙地结合了中序遍历的规则==
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/1e37a344bad84b83820e5538043ce99f.png)


## 二叉树的统一迭代方式

==使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。==

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;
    }
};

## 层序遍历只需记住这个标准模板块
```cpp
/**
 * 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*>que;
        if(root!=NULL) que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int size=que.size();//得出队列此层的大小；
            vector<int> vec;
            for(int i=0;i<size;i++){
                TreeNode*node=que.front();
                que.pop();
                vec.push_back(node->val);//加入每一层的数组值
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);//返回每一层的数组

            
        }
    return result;

    }
};