代码随想录算法训练营第十四天|二叉树理论及二叉树的遍历

岁岁生花，日日望月

已于 2023-11-10 22:51:37 修改

阅读量49

点赞数

分类专栏：代码随想录算法训练营打卡文章标签：算法数据结构

于 2023-11-08 17:53:32 首次发布

本文链接：https://blog.csdn.net/2301_80172303/article/details/134269102

版权

代码随想录算法训练营打卡专栏收录该内容

22 篇文章 1 订阅

订阅专栏

二叉树的理论基础：

二叉树的种类：满二叉树、完全二叉树、二叉搜索树、平衡二叉树。满二叉树也是完全二叉树的一种。完全二叉树是除树的最底层每填满之外，其余的层左右节点都是满的，最底层的左右节点是连续的。完全二叉树：满二叉树：

二叉搜索树是一个有序树，它的左子树若不空所有左子树上的结点就都小于根节点，它的右子树若不为空则所有右子树上的结点均大于根节点。

平衡二叉树就是左子树的高度和右子树的高度差的绝对值不能超过1，否则就不是平衡二叉树了。C++中的map和set、multimap和multiset的底层实现都是平衡二叉树。

二叉树的存储方式：

二叉树的存储方式有链式存储和线性存储等方式。链式存储是两个指针一个指向左孩子，一个指向右孩子。线性存储就是用数组来存储，数组下标从根节点开始。

二叉树的遍历：

二叉树的遍历分为深度优先搜索（用递归的方式或迭代法）和广度优先搜索（层序遍历）。

深度优先搜索：先往深走，遇到叶子节点再往回走。前后中序遍历序列就是深搜，这里的前后中说的是根节点的遍历顺序。

广度优先搜索：一层一层的遍历。

递归遍历（深搜）：

要点：（1）确定递归函数的参数和返回值。（2）确定终止条件。（3）确定单层递归的逻辑。前序遍历：144. 二叉树的前序遍历 - 力扣（LeetCode）

具体代码如下：

/**
 * 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 traversal(TreeNode* cur,vector<int>& vec){
        if(cur == NULL) 
        return;
        vec.push_back(cur->val);
        traversal(cur->left,vec);
        traversal(cur->right,vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

中序遍历和后序遍历只是改变了traversal函数中根节点的遍历顺序。

迭代法：

用栈实现非递归遍历二叉树的一个操作，但是栈的特点是先进后出的，所以在遍历时要尤其注意遍历的顺序，比如说：前序遍历时是中左右的一个顺序遍历，但是因为用栈实现，所以入栈顺序要变成中右左，出栈顺序才为中左右。

具体代码如下：

前序遍历

/**
 * 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) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == NULL) return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();//将根节点pop出，再存入result数组
            result.push_back(node->val);//中
            if(node->right) st.push(node->right);//右
            if(node->left) st.push(node->left);//左
        }
        return 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> 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;
    }
};

中序遍历

/**
 * 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();//如果指针cur此时指向空，就从栈中取元素
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;//再将指针指向该节点的右孩子
            }
        }
        return result;
    }
};

层序遍历（广搜）：

层序遍历因为是一层一层的遍历，就会存在一个问题就是，当前遍历的元素是第几层的，所以每遍历一层就要记录一层的节点数量size。层序遍历可以用队列来实现。

具体代码：

class Solution {
public:
    //层序遍历二叉树
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;//定义一个队列
        vector<vector<int>> result;//根据题意层序遍历后结果是一个二维数组
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();//记录每层元素个数
            vector<int> vec;//只能定义在循环里是因为每层都需要一个数组来储存
            while(size--){//将此层元素pop出，推入vec数组
                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);//将每层元素所在的数组存入此二维数组
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

实例应用：107. 二叉树的层序遍历 II - 力扣（LeetCode）

/**
 * 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>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;//定义一个队列
        vector<vector<int>> result;//根据题意层序遍历后结果是一个二维数组
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();//记录每层元素个数
            vector<int> vec;//只能定义在循环里是因为每层都需要一个数组来储存
            while(size--){//将此层元素pop出，推入vec数组
                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);//将每层元素所在的数组存入此二维数组
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

二叉树的定义：

二叉树的定义与链表相同：

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

岁岁生花，日日望月

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第十四天|二叉树理论及二叉树的遍历

int val;
复制链接

扫一扫

专栏目录

代码随想录算法训练营第十四天|二叉树理论及二叉树的遍历

二叉树的理论基础：

二叉树的存储方式：

二叉树的遍历：

递归遍历（深搜）：

迭代法：

层序遍历（广搜）：

二叉树的定义：