代码随想录算法训练营第14天||二叉树的● 理论基础● 递归遍历 ● 迭代遍历

二叉树的理论基础：

二叉树的种类：说几种常见的。

1.满二叉树：节点个数为2^K -1 的二叉树，K为树的高度

2.完全二叉树：满足两个条件：（1）除了最后一层，其他各层组成的树为满二叉树（2）最后一层节点从左到右排列。

3.二叉搜索树：满足左子树的值小于根节点，右子树的值大于根节点的二叉树。同时它的左右子树也是二叉搜索树

4.平衡二叉搜索树：树的左右子树高度差绝对值不超过1的二叉搜索树，同时左右子树都是平衡二叉搜索树。如下图

二叉树的存储方式：

链式存储：一个二叉树的节点可以由一个数据域和两个指针域构成，其中一个指针域指向左孩子，一个指针域指向右孩子。

顺序存储：使用数组存储二叉树的值，按照层次遍历的顺序。

二叉树的遍历方式：

深度优先遍历方式：

前序遍历：根左右

先访问树的根，然后访问数的左节点最后访问树的右节点。

中序遍历：左根右

先访问树的左节点，然后访问树的根最后访问树的右节点。

后序遍历：左右根

先访问树的左节点，然后访问树的右节点最后访问树的根。

广度优先遍历方式：

层次遍历：从根节点按照满二叉树的方式，一层一层往下遍历。

如图：

代码实现：

递归方法：

递归方法我有点讲不清，王卓老师的公开课讲的非常明白(P88  13分30秒后)。

代码如下：

前序遍历：

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

中序遍历：

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

后序遍历：

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

代码如下：

迭代方法：

迭代方法如图：

代码如下：

前序遍历:

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

中序遍历：

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

后序遍历：

class Solution {
    public:
    void resever(vector<int> &nums,int start,int end)
    {
        for(int i =start,j = end;i<j;i++,j--)
        {
            int temp;
            temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root==NULL) return result;
        TreeNode*cur = root;
        st.push(root);
        while(!st.empty())
        {
            cur = st.top();
            st.pop();
            result.push_back(cur->val);
            if(cur->left)
            {
                st.push(cur->left);
            }
            if(cur->right)
            {
                st.push(cur->right);
            }
        }
        resever(result,0,result.size()-1);
        return result;
    }
};