算法训练营第14天|二叉树基本概念 二叉树的递归遍历 二叉树的迭代遍历 二叉树的统一遍历

开启新的篇章----二叉树

二叉树的基本概念

二叉树的种类：

满二叉树：

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

完全二叉树：

一个二叉树，除了最底层节点可能没填满，其余每层节点数都达到最大值。

二叉搜索树：

前面的二叉树是没有数值的，该二叉树有数值，其左子树的数值要小于根节点数值，根节点数值要小于右子树的数值。

平衡二叉搜索树：

它是一颗空树或者它的左右两个子树高度差的绝对值不超过1，且左右两个子树都是一棵平衡二叉树。

二叉树的存储方式：

二叉树可以链式存储，也可以顺序存储。

链式存储：

采用元素节点值＋左指针+右指针的方式。

顺序存储：

采用数组的形式存储，进行层序遍历

二叉树的遍历方式：

分为深度优先遍历和广度优先遍历。

深度优先遍历：

前序遍历（递归法，迭代法）

中序遍历（递归法，迭代法）

后续遍历（递归法，迭代法）

广度优先遍历：

层次遍历（迭代法）

二叉树的定义：

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

二叉树的递归遍历：

LeetCode 144.二叉树的前序遍历

题目链接：

144. 二叉树的前序遍历 - 力扣（LeetCode）

注意：traversal函数中的参量，vec前面要带&，这样值才能传出来。

代码：

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

LeetCode 145.二叉树的后序遍历

题目链接：

145. 二叉树的后序遍历 - 力扣（LeetCode）

代码：

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

LeetCode 95.二叉树的中序遍历

题目链接：

94. 二叉树的中序遍历 - 力扣（LeetCode）

代码：

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

二叉树的迭代遍历

 LeetCode 144.二叉树的前序遍历

题目链接：

144. 二叉树的前序遍历 - 力扣（LeetCode）

代码：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>vec;
        if(root==nullptr) return vec;
        else{
            st.push(root);
        }
        while(!st.empty()){
            TreeNode*Node = st.top();
            st.pop();
            vec.push_back(Node->val);
            if(Node->right) st.push(Node->right);
            if(Node->left) st.push(Node->left);
        }
        return vec;
    }
};

LeetCode 145.二叉树的后序遍历

题目链接：

145. 二叉树的后序遍历 - 力扣（LeetCode）

解题思路：

前序：中左右->改变入栈顺序变成：中右左->反转数组：左右中，即为后序遍历

代码：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>vec;
        if(root==NULL) return vec;
        else{
            st.push(root);
        }
        while(!st.empty()){
            TreeNode*Node = st.top();
            st.pop();
            vec.push_back(Node->val);
            if(Node->left) st.push(Node->left);
            if(Node->right) st.push(Node->right);
        }
        reverse(vec.begin(),vec.end());
        return vec;
    }
};

LeetCode 95.二叉树的中序遍历

题目链接：

94. 二叉树的中序遍历 - 力扣（LeetCode）

代码：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>vec;
        TreeNode*cur=root;
        while(cur!=NULL||!st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur = cur->left;
            }
            else{
                TreeNode*Node = st.top();
                vec.push_back(Node->val);
                st.pop();
                cur = Node->right;
            }
        }
        return vec;
    }
};

二叉树的统一遍历 

LeetCode 144.二叉树的前序遍历

题目链接：

144. 二叉树的前序遍历 - 力扣（LeetCode）

代码：

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