代码随想录算法训练营第十三天|二叉树的递归遍历 、迭代遍历、统一迭代、层序遍历

二叉树

代码随想录链接：代码随想录 (programmercarl.com)

二叉树分为满二叉树和完全二叉树

满二叉树

如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

完全二叉树

除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。

二叉搜索树

节点有数值，是一个有序树。

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

平衡二叉树

又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树的存储方式

链式存储和顺序存储。

链式存储：使用指针

顺序存储：使用数组。如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

二叉树的遍历方式

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

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

进一步地：

• 深度优先遍历
  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）
• 广度优先遍历
  • 层次遍历（迭代法）

中间节点的顺序就是所谓的遍历方式

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

栈是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。

而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

定义（代码）

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

递归遍历

代码随想录链接：代码随想录 (programmercarl.com)

写递归前确定三个要素：

1. 参数和返回值

2. 终止条件

3. 单层递归的逻辑

以二叉树的前序遍历为例：

1. 参数是树的根节点和用来输出的vector，不需要返回值

2. 终止条件：遍历的指针为空时就停止。

3. 单层递归的逻辑：前序遍历是根左右

class Solution {
public:
    void pre(TreeNode* root, vector<int>& result){
        if(root==NULL){
            return;
        }
        else{
            result.push_back(root->val);
            pre(root->left,result);
            pre(root->right,result);
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        pre(root,result);
        return result;

    }
};

中序：

class Solution {
public:
    void mid(TreeNode* root, vector<int>& result){
        if(root==NULL){
            return;
        }
        else{
            mid(root->left,result);
            result.push_back(root->val);
            mid(root->right,result);
        }
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        mid(root,result);
        return result;

    }
};

后序：

class Solution {
public:
    void post(TreeNode* root, vector<int>& result){
        if(root==NULL){
            return;
        }
        else{
            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;
    }
};

迭代遍历

递归的逻辑能够使用栈来实现：递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中

前序：

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

中序：

与前序遍历不同，中序遍历的对节点的访问顺序和处理顺序不同，因此需要一个单独的指针来遍历，用栈来处理。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        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=node->right;
            }
        }
        return result;
    }
};

后序：

前序的中左右，子树部分先“反转”：中右左，整体结果反转得到后序的左右中 

class Solution {
public:
    vector<int> postorderTraversal(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->left) st.push(node->left);
            if(node->right) st.push(node->right);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

统一迭代

通过在需要处理的节点后面push一个空节点达到打标记的效果。

中序：

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();
                result.push_back(node->val);
                st.pop();
            }
        }
        return result;
    }
};

前序后序对应的更改节点push顺序即可。空节点都是在中间节点的后面push 

层序遍历

代码随想录链接：代码随想录 (programmercarl.com)

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()){
            vector<int> vec;
            int size=que.size();
            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;
    }
};