二叉树的创建与遍历

原创 已于 2023-09-08 10:24:12 修改 · 6.5k 阅读 · 58 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #C++
于 2022-12-10 15:58:07 首次发布

目录

一、前言

二、二叉树的创建

三、二叉树的遍历

1. 前序遍历

2.中序遍历

3.后序遍历

四、完成代码

1. 前序创建，前序递归、非递归遍历

2. 前序创建，中序递归、非递归遍历

3. 前序创建，后序递归、非递归遍历

4.层次遍历

五、加入圈子

一、前言

二叉树由节点（Node）构成，每个节点都有一个值（value）和至多两个指向子节点的指针（left 和 right）。一个节点的子节点可以是叶节点（leaf node），也可以是一个包含多个子节点的二叉树。

二叉树有多种不同的遍历方法，比如先序遍历（preorder traversal）、中序遍历（inorder traversal）和后序遍历（postorder traversal）。每种遍历方法都有不同的应用场景。例如，先序遍历通常用于复制一棵二叉树，中序遍历通常用于排序，后序遍历通常用于计算一棵二叉树的高度。

二、二叉树的创建

通过二叉树序列的信息可以创建二叉树，但是知道什么信息才能创建二叉树呢，详细内容参见另一篇文章（扩展二叉树的中序序列创建二叉树？_木头linux的博客-CSDN博客），这里做个总结：

🍉 前序序列 + 中序序列；

🍉 后序序列 + 中序序列；

🍉 扩展前序序列；

🍉 扩展后序序列。

以上四种，知其一种即可创建二叉树，此处我们选择第三种方法，根据扩展前序序列创建二叉树，代码如下：

void pre_create_bitree (BiTree &bitree, vector<element_type>input)
{
    if(current_element == input.size())return;
    if(input[current_element] == '#')
    {
        cout<< "#"<<" ";
        bitree = NULL;
        current_element++;
        return;
    }
    else
    {
        bitree = new BiNode;
        bitree->data = input[current_element++];
        cout << input[current_element - 1]<< " ";
        pre_create_bitree(bitree->lchild, input);
        pre_create_bitree(bitree->rchild, input);
    }
}

void create_bitree (BiTree &bitree)
{
    vector<element_type> input_elem = {'1', '2', '4', '#', '#', '5', '#', '#', '3', '6', '#', '#', '7', '#', '#'};;
    pre_create_bitree(bitree, input_elem);
}

三、二叉树的遍历

二叉树遍历指的是按照一定的顺序访问二叉树中的所有节点。通常情况下，我们可以使用三种不同的方法来遍历二叉树：

🍊 前序遍历：首先访问当前结点，在访问左子树，最后访问右子树。

🍊 中序遍历：先访问当前结点左子树，再访问该结点，最后访问该结点的右子树。

🍊 后序遍历：先访问当前结点左子树，再访问右子树，完成该结点左右子树访问后，再访问该节点。

1. 前序遍历

🍅 递归遍历 🍅

在该代码中，如果当前节点不为空，则先访问当前节点，然后递归地访问左子树，再递归地访问右子树。这样的遍历顺序为：根节点 -> 左子树 -> 右子树，即先序遍历。该代码的流程如下：

  1. 判断当前节点是否为空，如果为空则返回。
  2. 访问当前节点。
  3. 递归地访问当前节点的左子树。
  4. 递归地访问当前节点的右子树。
  5. 返回。
// 先序遍历（递归）
void pre_order_traverse(BiTree bitree)
{
    if(bitree)
    {
        cout << bitree->data<< " ";// 访问根节点
        pre_order_traverse(bitree->lchild);// 访问左子树
        pre_order_traverse(bitree->rchild);// 访问右子树
    }
    // return;// 可以省略
}

🍅 非递归遍历 🍅

在该代码中，使用了栈的数据结构来模拟递归的过程。这样的遍历顺序为：根节点 -> 左子树 -> 右子树，即先序遍历。该代码的流程如下：

  1. 创建一个栈，将二叉树的根节点入栈。
  2. 只要当前节点不为空或者栈不为空，则循环。
  3. 如果当前节点不为空，则访问当前节点，然后将当前节点的左子树入栈，并将当前节点更新为其左子树。
  4. 如果当前节点为空，则取出栈顶元素，并更新当前节点为其右子树。
  5. 重复上述步骤。
// 先序遍历（非递归）
void pre_order_traverse_none(BiTree bitree)
{
    // 思路：先序顺序为：根节点->左子树->右子树
    // 当遍历完左子树之后找不到右子树
    // 解决方法：记住根节点
    
    stack<BiTree> stk;
    BiTree p = bitree;
    // 当前节点不为空，或者栈不为空
    while(p || !stk.empty())
    {
        if(p)// 根节点不为空
        {
            cout << p->data<< ",";
            stk.push(p);// 根指针入栈
            p = p->lchild;// 遍历左子树
        }
        else// 栈不为空
        {
            p = stk.top();// 获取根节点
            stk.pop();// 弹出根节点
            p = p->rchild;// 访问右子树
        }
    }

}

2.中序遍历

🍓 递归遍历 🍓

在该代码中，如果当前节点不为空，则先递归地访问左子树，再访问当前节点，最后递归地访问右子树。这样的遍历顺序为：左子树 -> 根节点 -> 右子树，即中序遍历。该代码的流程如下：

  1. 判断当前节点是否为空，如果为空则返回。
  2. 递归地访问当前节点的左子树。
  3. 访问当前节点。
  4. 递归地访问当前节点的右子树。
  5. 返回。
// 中序遍历二叉树（递归）
void in_order_traverse(BiTree &bitree)
{
    if(bitree)
    {
        in_order_traverse(bitree->lchild);
        cout << bitree->data<<" ";
        in_order_traverse(bitree->rchild);
    }
}

前序遍历与中序遍历递归实现方法的代码类似之处：

  • 递归函数的结构相似，都是判断当前节点是否为空，如果为空则返回。
  • 递归函数的实现方法相似，都是先递归地访问左子树，再访问当前节点，最后递归地访问右子树。

不同之处，前序遍历在遍历到一个节点之前，会先访问该节点，而中序遍历在遍历到一个节点之时，会访问该节点。因此，前序遍历与中序遍历在访问节点的顺序上有所区别。

🍓 非递归遍历 🍓

用这种方法遍历一棵树，会按照中序遍历的顺序访问每个节点，也就是左子树->根节点->右子树。具体实现过程是这样的：

  • 首先检查当前节点是否为空，如果为空，就从栈中弹出一个节点，并访问它。如果不为空，就将当前节点压入栈中，然后将当前节点更新为它的左子节点，再次检查当前节点是否为空。这样可以保证在遍历完左子树之后，能够找到根节点。
  • 当遍历完左子树之后，如果栈不为空，就从栈中弹出一个节点，并访问它（此时的节点就是根节点）。然后将当前节点更新为它的右子节点，再次检查当前节点是否为空。
  • 如果当前节点为空并且栈为空，就说明遍历结束。
// 中序遍历二叉树（非递归）
void in_order_traverse_none(BiTree &bitree)
{
    // 思路：中序顺序为：左子树->根节点->右子树
    // 当遍历完左子树之后找不到根节点
    // 解决方法：记住根节点

    BiTree p = bitree;
    stack<BiTree> stk;

    while(p || !stk.empty())
    {
        if(p)// 如果根节点非空，压栈，记录根节点
        {
            stk.push(p);
            p = p->lchild;// 首先遍历左子树
        }
        else// 栈非空，弹出根节点
        {
            p = stk.top();
            cout << p->data<<" " ;
            stk.pop();
            p = p->rchild;// 访问右子树
        }
    }
}

对于前序遍历和中序遍历的非递归实现，最大的区别在于，对于当前节点，前序遍历是先访问当前节点，然后遍历左子树和右子树，而中序遍历是先遍历左子树，然后访问当前节点，最后遍历右子树。

3.后序遍历

🍈 递归遍历 🍈

与前两种无明显区别，不再详细叙述。

void post_order_traverse(BiTree &bitree)
{
    if(bitree)
    {
        post_order_traverse(bitree->lchild);
        post_order_traverse(bitree->rchild);
        cout << bitree->data<< " ";
    }
}

🍈 非递归遍历 🍈

与前序遍历和中序遍历的非递归算法相比，后序遍历非递归算法的实现更为复杂。

  • 首先，它需要维护一个 last_visit，用来存储已经被访问过的节点；
  • 其次，当遍历到一个节点时，需要先判断它的左右子树是否都已经被访问过，如果都被访问过了，就可以访问这个节点，否则，需要先将它的左右子树压入栈中，
  • 然后再继续遍历。

因此，后序遍历非递归算法的实现比前序遍历和中序遍历的非递归算法要复杂。

代码如下所示，在执行这段代码时，会按照如下步骤进行：

  1. 将根节点压入栈中，并访问根节点的左子树，即访问左子节点。
  2. 如果左子节点不为空，将左子节点压入栈中，并访问左子节点的左子树。
  3. 如果左子节点的左子树为空，取出栈顶元素，判断栈顶元素的右子树是否为空。
  4. 如果栈顶元素的右子树不为空，且没有被访问过，将右子树压入栈中，并访问右子树。
  5. 如果右子树为空，或者右子树已经被访问过了，则访问栈顶元素，并将栈顶元素出栈。
  6. 回到步骤3，继续遍历。

这样，在遍历完整棵树之后，就可以按照“左子树->右子树->根节点”的顺序访问每个节点。

// 与前序遍历和中序遍历不同
// 前序和中序遍历根节点和左孩子都是相邻输出的
// 后序遍历需要先访问右子树，最后输出根节点
void post_order_traverse_none(BiTree &bitree)
{
    // 将每一个非#元素看作根节点遍历一遍
    stack<BiTree> stk;
    BiTree cur = bitree;
    BiTree last_vist = NULL;// 用来区分返回根节点时，是从左子树返回的，还是右子树返回的
    BiTree top = NULL;
    while(cur || !stk.empty())
    {
        if(cur)cout<< cur->data<<endl;
        else cout<<"cur NULL"<<endl;

        if(cur)// 如果cur不为空，将其压入栈中，并访问左子树
        {
            stk.push(cur);
            cur = cur->lchild;
        }
        else// 如果当前结点cur为空，取出栈顶元素
        { 
            top = stk.top();// 取出栈顶元素
            
            if(top->rchild && last_vist != top->rchild)// 如果栈顶结点的右子节点不为空，且没有被访问过
            {
                cur = top->rchild;// 如果cur指向的左子树为空，从栈顶取出根节点，将cur指向其右子树
            }
            else// 右子节点为空，且从右子树返回（一定是右子树返回，无论右子树是否为空）
            {
                // 否则，访问栈顶元素
                cout<< top->data<< "输出"<<endl;
                // 将栈顶元素设为最后访问的元素
                last_vist = top;
                // 将栈顶元素出栈
                stk.pop();
            }
        }
    }
    
}

四、完成代码

1. 前序创建，前序递归、非递归遍历

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

#define element_type char
// 二叉树节点结构体
typedef struct BitNode
{
    element_type data;// 数据域
    BitNode *lchild, *rchild;// 左右孩子
}BitNode, *BiTree;

int current_num = 0;// 构建二叉树时用于递归计数

// 创建二叉树
void create_bitree(BiTree &bitree);// 注意这里必须要使用引用传值，或者指针传值，形参不可以

// 前序遍历输出二叉树（递归）
void pre_order_traverse(BiTree bitree);

// 前序遍历输出二叉树（非递归）
// 使用栈的原因是：通过根节点可以找到左子树，但是遍历完成左子树找不到右子树
void pre_order_traverse_none(BiTree BiTree);

// 主函数
int main()
{
    BiTree bi_tree;

    // 创建二叉树
    create_bitree(bi_tree);// 如果不是引用传值，这里的bi_tree在函数运行完之后仍然是空
    cout << "二叉树已创建"<<endl;

    // 先序遍历二叉树（递归）
    cout << "线序遍历二叉树（递归）"<<endl;
    pre_order_traverse(bi_tree);
    cout <<endl;

    // 先序遍历二叉树（非递归）
    cout << "先序遍历二叉树（非递归）"<<endl;
    pre_order_traverse_none(bi_tree);
    
    return 0;
}

// 先序遍历构建二叉树(递归)
// 这里同样需要引用或指针传值
void pre_create_bitree(BiTree &bitree, vector<element_type> input_element)
{
    if(current_num == input_element.size())return;
    if(input_element[current_num] == '#')
    {
        bitree = NULL;
        current_num++;
        return;
    }
    else
    {
        bitree = new BitNode;// 首先申请空间
        bitree->data = input_element[current_num++];// 数值域赋值
        pre_create_bitree(bitree->lchild, input_element);// 递归左子树
        pre_create_bitree(bitree->rchild, input_element);// 递归右子树
    }
}

// 创建二叉树
void create_bitree(BiTree &bitree)
{
    // 先序序列
    // 补充空节点之后，按照先序序列建立的二叉树就是唯一的
    vector<element_type> input = {'1', '2', '4', '#', '#', '5', '#', '#', '3', '6', '#', '#', '7', '#', '#'};
    pre_create_bitree(bitree, input);// 如果不是引用传值，这里的bitree在运行完函数之后仍然是空
}

// 先序遍历（递归）
void pre_order_traverse(BiTree bitree)
{
    if(bitree)
    {
        cout << bitree->data<< " ";// 访问根节点
        pre_order_traverse(bitree->lchild);// 访问左子树
        pre_order_traverse(bitree->rchild);// 访问右子树
    }
    // return;// 可以省略
}

// 先序遍历（非递归）
// 参考链接：https://www.cnblogs.com/zhulmz/p/11861058.html
void pre_order_traverse_none(BiTree bitree)
{
    // 思路：先序顺序为：根节点->左子树->右子树
    // 当遍历完左子树之后找不到右子树
    // 解决方法：记住根节点
    
    stack<BiTree> stk;
    BiTree p = bitree;
    // 当前节点不为空，或者栈不为空
    while(p || !stk.empty())
    {
        if(p)// 根节点不为空
        {
            cout << p->data<< ",";
            stk.push(p);// 根指针入栈
            p = p->lchild;// 遍历左子树
        }
        else// 栈不为空
        {
            p = stk.top();// 获取根节点
            stk.pop();// 弹出根节点
            p = p->rchild;// 访问右子树
        }
    }

}

 前序迭代遍历，添加了详细的注释，摘自我的力扣题目答案：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)return res;
        TreeNode* p = root;
        stack<TreeNode*> stk;// 记录需要回溯的父节点
        while(p || !stk.empty())// 这里的p理解为当前节点
        {
            // 当前节点不为空，访问当前节点并记录当前节点，然后访问左子树
            // 这里体现出根->左
            if(p != NULL)
            {
                res.emplace_back(p->val);// 先访问当前节点
                stk.push(p);// 因为下面就访问左子树，因此记录当前节点为父节点，便于回溯
                p = p->left;// 访问左子树
            }
            else
            {
                // 当前节点为空，从栈中取出父节点作为当前节点，并访问当前节点的右子树。
                //因为从栈中拿出来的父节点作为当前节点一定是被访问过的，所以直接访问右字数即可。这里体现出根->左完成之后的右，因为从栈中取出，一定完成了根->左这个过程
                p = stk.top();
                stk.pop();
                p = p->right;
            }
        }
        return res;
    }
};

2. 前序创建，中序递归、非递归遍历

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

#define elemtype char
// 二叉树节点
typedef struct BiNode
{
    elemtype data;
    BiNode *lchild, *rchild;
}BiNode, *BiTree;

int current_element = 0;// 当前元素下标

// 中序构建二叉树
void create_bitree(BiTree &bitree);

// 中序遍历二叉树（递归）
void in_order_traverse(BiTree &bitree);

// 中序遍历二叉树（非递归）
void in_order_traverse_none(BiTree &bitree);

int main()
{
    BiTree bi_tree;
    create_bitree(bi_tree);
    cout <<"二叉树构建完成！"<<endl;
    cout <<endl;
    cout <<"中序遍历二叉树（递归）"<<endl;
    in_order_traverse(bi_tree);
    cout << endl;

    cout <<"中序遍历二叉树（非递归）"<<endl;
    in_order_traverse_none(bi_tree);

    return 0;
}

// 先序遍历递归方式创建二叉树
void pre_create_bitree(BiTree &bitree, vector<elemtype> input_element)
{
    if(current_element == input_element.size())return;
    
    if(input_element[current_element] == '#')
    {
        bitree = NULL;
        current_element++;
        cout << "#"<< " ";
        return;
    }
    else
    {   
        bitree = new BiNode;
        bitree->data = input_element[current_element++];// 根节点赋值
        cout <<input_element[current_element-1]<< " ";
        pre_create_bitree(bitree->lchild, input_element);// 左子树构建
        pre_create_bitree(bitree->rchild, input_element);// 右子树构建
    }
}

// 创建二叉树
void create_bitree(BiTree &bitree)
{
    vector<elemtype> input = {'1', '2', '4', '#', '#', '5', '#', '#', '3', '6', '#', '#', '7', '#', '#'};
    pre_create_bitree(bitree, input);
}

// 中序遍历二叉树（递归）
void in_order_traverse(BiTree &bitree)
{
    if(bitree)
    {
        in_order_traverse(bitree->lchild);
        cout << bitree->data<<" ";
        in_order_traverse(bitree->rchild);
    }
}

// 中序遍历二叉树（非递归）
void in_order_traverse_none(BiTree &bitree)
{
    // 思路：中序顺序为：左子树->根节点->右子树
    // 当遍历完左子树之后找不到根节点
    // 解决方法：记住根节点

    BiTree p = bitree;
    stack<BiTree> stk;

    while(p || !stk.empty())
    {
        if(p)// 如果根节点非空，压栈，记录根节点
        {
            stk.push(p);
            p = p->lchild;// 首先遍历左子树
        }
        else// 栈非空，弹出根节点
        {
            p = stk.top();
            cout << p->data<<" " ;
            stk.pop();
            p = p->rchild;// 访问右子树
        }
    }
}

3. 前序创建，后序递归、非递归遍历

#include <iostream>
#include <stack>    
#include <vector>

using namespace std;

#define element_type char

// 二叉树结点
typedef struct BiNode
{
    element_type data;
    BiNode *lchild, *rchild;
}BiNode, *BiTree;

int current_element = 0;// 当前元素计数

void create_bitree(BiTree &bitree);// 创建二叉树

void post_order_traverse(BiTree &bitree);// 后序遍历二叉树（递归）

void post_order_traverse_none(BiTree &bitree);// 后序遍历二叉树（非递归）

int main()
{
    BiTree bi_tree;
    // 创建二叉树
    create_bitree(bi_tree);
    cout<<endl; 

    // 后序遍历二叉树（递归）
    post_order_traverse(bi_tree);
    cout<<endl;

    // 后序遍历二叉树（非递归）
    post_order_traverse_none(bi_tree);
    cout<< endl;
    
    return 0;
}

void pre_create_bitree (BiTree &bitree, vector<element_type>input)
{
    if(current_element == input.size())return;
    if(input[current_element] == '#')
    {
        cout<< "#"<<" ";
        bitree = NULL;
        current_element++;
        return;
    }
    else
    {
        bitree = new BiNode;
        bitree->data = input[current_element++];
        cout << input[current_element - 1]<< " ";
        pre_create_bitree(bitree->lchild, input);
        pre_create_bitree(bitree->rchild, input);
    }
}

void create_bitree (BiTree &bitree)
{
    vector<element_type> input_elem = {'1', '2', '4', '#', '#', '5', '#', '#', '3', '6', '#', '#', '7', '#', '#'};;
    pre_create_bitree(bitree, input_elem);
}

void post_order_traverse(BiTree &bitree)
{
    if(bitree)
    {
        post_order_traverse(bitree->lchild);
        post_order_traverse(bitree->rchild);
        cout << bitree->data<< " ";
    }
}
// 与前序遍历和中序遍历不同
// 前序和中序遍历根节点和左孩子都是相邻输出的
// 后序遍历需要先访问右子树，最后输出根节点
void post_order_traverse_none(BiTree &bitree)
{
    // 将每一个非#元素看作根节点遍历一遍
    stack<BiTree> stk;
    BiTree cur = bitree;
    BiTree last_vist = NULL;// 用来区分返回根节点时，是从左子树返回的，还是右子树返回的
    BiTree top = NULL;
    while(cur || !stk.empty())
    {
        if(cur)cout<< cur->data<<endl;
        else cout<<"cur NULL"<<endl;

        if(cur)// 如果cur不为空，将其压入栈中，并访问左子树
        {
            stk.push(cur);
            cur = cur->lchild;
        }
        else// 如果当前结点cur为空，取出栈顶元素
        { 
            top = stk.top();// 取出栈顶元素
            
            if(top->rchild && last_vist != top->rchild)// 如果栈顶结点的右子节点不为空，且没有被访问过
            {
                cur = top->rchild;// 如果cur指向的左子树为空，从栈顶取出根节点，将cur指向其右子树
            }
            else// 右子节点为空，且从右子树返回（一定是右子树返回，无论右子树是否为空）
            {
                // 否则，访问栈顶元素
                cout<< top->data<< "输出"<<endl;
                // 将栈顶元素设为最后访问的元素
                last_vist = top;
                // 将栈顶元素出栈
                stk.pop();
            }
        }
    }
    
}

4.层次遍历

#include <iostream>
#include <queue>// 使用队列

using namespace std;

#define elem_type char

// 二叉树结点创建
typedef struct BiNode
{
    elem_type data;
    BiNode *lchild, *rchild;
}BiNode, *BiTree;

int current_elem = 0;// 当前遍历元素

void create_bitree(BiTree &bitree);// 前序遍历创建二叉树

void level_order_traverse(BiTree &bitree);// 层次遍历二叉树


// 二叉树层次遍历：
// 对于一棵二叉树，从根节点开始，从上到下，从左到右的顺序访问每一个结点
// 思路：
// 将根节点入队；
// 队不为空则进行循环：
// 0.出列一个结点，打印输出
// 1.如果有左孩子，将左孩子入队
// 2.如果有有孩子，将右孩子入队
int main()
{
    BiTree bitree;
    // 创建二叉树
    create_bitree(bitree);

    // 层次遍历二叉树
    cout<<"层次遍历"<<endl;
    level_order_traverse(bitree);
    
    return 0;
}

void pre_create_bitree(BiTree &bitree, vector<elem_type> input)
{
    if(current_elem == input.size())return;
    if(input[current_elem] == '#')
    {
        cout<< "#"<<endl;
        bitree = NULL;
        current_elem++;
        return;
    }
    else
    {
        bitree = new BiNode;
        bitree->data = input[current_elem++];
        cout<< input[current_elem - 1]<<endl;
        pre_create_bitree(bitree->lchild, input);
        pre_create_bitree(bitree->rchild, input);
    }
}

void create_bitree(BiTree &bitree)
{
    // 先序序列
    // 补充空节点之后，按照先序序列建立的二叉树就是唯一的
    vector<elem_type> input = {'1', '2', '4', '#', '#', '5', '#', '#', '3', '6', '#', '#', '7', '#', '#'};
    pre_create_bitree(bitree, input);// 如果不是引用传值，这里的bitree在运行完函数之后仍然是空
}

void level_order_traverse(BiTree &bitree)
{
    BiTree p = bitree;// 获取队列头部元素临时变量
    queue<BiTree> que;// 定义存储队列
    que.push(p);// 根节点入队
    while(!que.empty())
    {
        p = que.front();// 获取队列头部元素
        // 因为下面判断了，压栈的内容p不会为空，这里可以无需判断
        cout<< p->data<< " ";// 打印队列头部元素
        que.pop();// 出队
        if(p->lchild != NULL)que.push(p->lchild);
        if(p->rchild != NULL)que.push(p->rchild);
    }
}

五、加入圈子

🍎欢迎大家加入组织，一起交流、学习，群内多为嵌入式爱好者，也有企业MCU、Linux大佬carry。

🍎 球球群：【嵌入式c、c++、单片机、linux技术交流2群】🍎左侧专栏或下方群名片。

二叉树的创建和基本操作（详解）
oorik的博客
09-27 2万+
本文主要讲解递归实现二叉树的代码，对于树，二叉树的性质概念不多赘述我们以'#'代表空结点(为已有结点下的左右空孩子)，方便创建二叉树，我们以下图的二叉树作为讲解。
别再到处搜了！这份LaTeX符号速查表（含数学、逻辑、集合、箭头）够你用一辈子
最新发布
weixin_30312563的博客
04-30 341
本文提供了一份全面的LaTeX符号速查表，涵盖数学、逻辑、集合和箭头等常用符号，帮助用户高效完成学术写作和论文排版。通过智能分类和实用技巧，解决LaTeX符号输入难题，提升写作效率。
二叉树的创建（数据结构） C语言版
m0_67400973的博客
06-21 2万+
目录一.二叉树的存储结构二.二叉树的创建三.二叉树的遍历1.先序遍历2.中序遍历3.后序遍历4.层序遍历二叉树的基本存储结构如下所示leftchild:存储左孩子节点的地址rightchild:存储右孩子节点的地址data：当前节点存储的信息 二.二叉树的创建 创建一棵二叉树的关键在于如何将一个一个的节点按照树的脉络连接起来，在这里我们选择用一棵最小的满二叉树来说明我们需要首先创建根节点，并且向里面保存数据，然后接着在向左孩子里面输入数据，最后是右孩子，其实这种从根节点开始，依次访问左节点，右节点的方式叫做
求二叉树总结点数、叶子结点数
渣渣修炼记
11-15 2744
求二叉树结点数
数据结构基础系列(6)：树和二叉树
10-18
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第6部分“树和二叉树”，介绍树的相关概念和表示方法，重点是二叉事的性质、存储结构、遍历等基本操作的实现，以及应用基本操作解决问题的方法。
二叉树的各种创建方法
热门推荐
lingling_nice的博客
07-08 7万+
1.前序创建#include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; typed
C语言二叉树的创建与遍历
le123didi的博客
10-09 1万+
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。以下是对链式存储结构的二叉树的创建与先序、中序、后序遍历操作。
二叉树的创建与三种遍历方式（带图文详解）
yohe12的博客
12-22 1万+
本文讲解了如何创建二叉树，及二叉树的三种遍历方式。
C++二叉树的创建与遍历
dayuhaitang1的博客
03-19 5038
最近学习了二叉树的一点知识，感觉数据结构真的很难啊，所以学习过程中的笔记还是要记录一下。 文章目录一、二叉树二、实现代码三、运行效果四、小结 一、二叉树 在我们使用的数据结构中，一对一的线性结构使我们经常所使用到的，但是现实中却有着许多一对多的情况，这也就产生了“树”这一概念。二叉树则是“树”这一概念中的一种特殊情况，其定义为：“是n(n>=0)个结点的有限集合。该集合或者为空集(称为空二叉...
二叉树的创建和遍历
zuojiejie的博客
11-29 7439
二叉树的创建可以选择顺序存储方式创建二叉树和链式存储方式创建二叉树。我们为了创建一棵完整的二叉树，需要对普通的二叉树进行拓展，如图所示：其实建立二叉树也是利用了递归的原理。只不过在原来应该是打印结点的地方，改成了生成结点，给结点赋值的操作而已。大家可以先看后面的二叉树的遍历，再来看二叉树的创建。
二叉树的创建及遍历方法
m0_45901455的博客
08-02 4万+
在这里我们发现，我们每次存储时，基本上都是按照从上到下，从左到右的方式进行存储的，所以，我们此处存储数据时，可以先把根节点下面的左子树先存放完成，再存放右子树即可实现数据存储，并且，我们存放玩上一个数据之后的每一个节点都可以看做是一个根节点。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左孩子树和右孩子树组成的非空树；按照一般的存储逻辑，我们一般存储都是按照如下编号逐个存储，但是这样的存储方式不太适用于我们的链式存储，因此，这里我们需要使用到递归存储。......
二叉树的构建与遍历（先序、中序、后序、层次）
人生处处是围城，一切都是最好的安排！
01-14 1万+
二叉树的构建与遍历
数据结构——二叉链表创建二叉树（C语言版）
正弦定理的博客
12-08 6万+
数据结构——二叉链表创建二叉树一、思想（先序思想创建）：二、创建二叉树（1）传一级参数方法 一、思想（先序思想创建）： 第一步先创建根节点,然后创建根节点左子树,开始递归创建左子树，直到递归创建到的节点下不继续创建左子树，也就是当下递归到的节点下的左子树指向NULL，结束本次左子树递归，返回这个节点的上一个节点，开始创建右子树，然后又开始以当下这个节点，继续递归创建左子树，左子树递归创建完，就递归创建右子树，直到递归结束返回到上一级指针节点（也就是根节点下），此时根节点左边子树创建完毕，开始创建右边子树，
【数据结构入门实验】二叉树的建立和遍历完整代码
亿维数组's博客
05-22 4397
实验内容： 1．二叉树的建立与遍历（验证性实验） 问题描述 建立一棵二叉树，并对其进行遍历（先序、中序和后序），打印输出遍历结果。 基本要求 从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立），并采用递归 算法对其进行遍历（先序、中序和后序），将遍历结果打印输出。 测试数据 ABC□□DE□G□□F□□□（其中□表示空格字符），则输出结果为：先序为ABCDEGF，中序为 CBEGDFA， z 后序为CGBFDBA。 实验分析： 实验要求
二叉树的创建以及遍历
qq_51725723的博客
07-21 2423
**二叉树的存储方式有两种，一种是以链表的方式进行存储，一种是以数组的方式进行存储*当以数组的方式进行存储的时候，要注意节点之间的关系，假设根节点的位置为POS那么左子树的位置就是*2*POS+1，右子树的位置就是2*POS+2。正是由于这层关系，当二叉树不是满二叉树的时候，使用数组进行存储*是非常的浪费空间的，空间的利用率较低。*当以链表的方式存储二叉树的时候，每一个二叉树节点都含有一个左孩子指针和一个右孩子指针，两个指针分别*指向相应的节点，节省空间，并且更容易使用。*/...
二叉树的建立和遍历
m0_56246173的博客
11-22 3523
在二叉树的存储中，我们发现在创建二叉树函数的时候，，它的参数是char* &str,此处的&是c++中的引用，什么是引用呢？ 格式为：类型 &引用变量名 = 已定义过的变量名。 例如：,此处的引用b便是a的重命名，怎么理解呢，其实a,b指的是同一个变量，a,b只是他不同的名字。 此处为什么用引用呢，如果去掉引用会发生什么呢？ 在数组元素等于ABC##DE##F##G#H## 的时候，输出值会发生错误，发现只在abc之间，不会遍历到后面的元素。怎么样的思路呢，我们递归调用函数时，比如A结点接下来进入左孩子调用
二叉树的建立
sqrt_2的博客
07-21 2129
遍历二叉树，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。 设L、D、R分别表示遍历左子树、访问根结点和遍历右子树， 则对一棵二叉树的遍历有三种情况：DLR（称为先根次序遍历），LDR（称为中根次序遍历），LRD （称为后根次序遍历）。
6.2 二叉树遍历
你的指尖有改变世界的力量
02-05 1524
介绍了二叉树的三大遍历（前序、中序、后序）算法及应用
二叉树的4种构建
weixin_43811173的博客
08-11 5096
文章目录1.拓展二叉树的先序建立2.先序、中序序列建立3.拓展完全二叉树的顺序存储4.二叉排序树的插入构建 要确定唯一一棵二叉树，我们需要 先序+中序，后序＋中序，层序+中序 （必由中序和其他的搭配，中序可以划分左右子树） 1.拓展二叉树的先序建立 仅由先序序列无法确定一棵二叉树，但是我们将每个结点的空指针都引出一个“虚结点”，令其值为 ‘#’,表示为空结点，这样处理的二叉树称为原二叉树的拓展二叉树。 由拓展二叉树的先序序列可以唯一确定一棵二叉树。 #mermaid-svg-2rxyfcENKa028eM5
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Kashine

你的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值