C++学习笔记——二叉树

二叉树相关知识

树

一种常见的数据结构，用于模拟具有树状结构性质的数据集合。树也可以视作一个有向无环图。

二叉树

一种特殊的树状结构，每个节点最多具有两个子树，即一个根节点对应一个或两个叶子节点。
两个子树分别被称为左子树和右子树。

二叉树的遍历方法

• 前序遍历
• 中序遍历
• 后序遍历
• 层序遍历
  前序，中序，后序，分别按照根左右，左根右，左右根的顺序遍历二叉树，而层序遍历的遍历方式比较特殊，属于广度优先搜索，这种搜索方法广泛应用于树或图等数据结构中，首先从根节点开始访问，紧接着访问根节点的相邻节点，然后访问相邻节点的相邻节点，以此类推，访问三级邻接点，四级邻接点…

相关代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
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) {}
    
};

//前序遍历，按照根节点，左节点，右节点的顺序遍历树
void preorder(TreeNode* root, vector<int>& ans)
{
    if (root == nullptr)
    {
        return;
    }
    if (root != nullptr)
    {
        ans.push_back(root->val);
        preorder(root->left, ans);
        preorder(root->right, ans);
    }
   
}
vector<int> preorderTraversal(TreeNode* root)
{
    vector<int> ans;
    preorder(root, ans);
    return ans;
}

//中序遍历，按照左节点，根节点，右节点的顺序遍历树
void inorder(TreeNode* root, vector<int>& ans)
{
    if (root == nullptr)
    {
        return;
    }
    if (root != nullptr)
    {
        
        inorder(root->left, ans);
        ans.push_back(root->val);
        inorder(root->right, ans);
    }

}
vector<int> inorderTraversal(TreeNode* root)
{
    vector<int> ans;
    inorder(root, ans);
    return ans;
}

//后序遍历，按照左节点，右节点，根节点的顺序遍历树
void postorder(TreeNode* root, vector<int>& ans)
{
    if (root == nullptr)
    {
        return;
    }
    if (root != nullptr)
    {

        postorder(root->left, ans);
        postorder(root->right, ans);
        ans.push_back(root->val);
    }

}
vector<int> postorderTraversal(TreeNode* root)
{
    vector<int> ans;
    postorder(root, ans);
    return ans;
}

//层序遍历，应当采用的是广度优先搜索
vector<vector<int>> levelOrder(TreeNode* root) {

    //利用队列进行辅助。
    //一次循环，将要访问的值出队列
    //二次循环，将要访问的节点入队列
    vector<vector<int>> ans;
    //创建队列
    queue<TreeNode* > que;
    

    if (root == nullptr)
    {
        return ans;
    }
    if (root != nullptr)
    {
        que.push(root);
        while (!que.empty())//如果队列不为空
        {
            int que_length = que.size();
            ans.push_back(vector<int>());
            //循环遍历队列
            for (int i = 0; i < que_length; i++)
            {
                auto node = que.front();
                que.pop();
                ans.back().push_back(node->val);

                if (node->left)
                {
                    que.push(node->left);
                }
                if (node->right)
                {
                    que.push(node->right);
                }
            }
        }
    }
    return ans;

}
int main()
{
    std::cout << "Hello World!\n";
}