用C实现二叉树的遍历、存储

最新推荐文章于 2024-07-20 11:22:21 发布
最新推荐文章于 2024-07-20 11:22:21 发布
阅读量111 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构 stack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42224577/article/details/113739434
版权

目录

二叉树的知识点

在这里插入图片描述
1.节点的度：当前节点下面挂了几个子节点，就是多少度
2.节点的深度：从根节点往下看，当前节点位于第几层
3.节点的高度：从整个数的最后一层往上看，当前节点比最后一层高几层

在这里插入图片描述
在这里插入图片描述
节点是在前还是中还是后来看
在这里插入图片描述
在这里插入图片描述
完全二叉树，只有树的最右边的右子位可以缺少一个，其它地方都不能缺
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

排序二叉树


/**********************************************************
 这是一个排序二叉树，也叫查找二叉树，左子树的小于中间节点，中间节点小于右子树

可以将存储的数据由小到大打印输出
也可以由大到小打印输出

还可以将二叉树转化为广义表输出

 *******************************************************/





#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef struct Node
{
    int data;
    struct Node *lchild, *rchild;
}Node;

typedef struct Tree
{
    Node *root;
    int n;
}Tree;

Tree *GetNewTree()
{
    Tree *p = (Tree *)malloc(sizeof(Tree));
    p->root = NULL;
    p->n = 0;
    return p;
}

Node *GetNewNode(int val)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->lchild = p->rchild = NULL;
    return p;
}

Node* insert_binary_node(Node *node,int val,int *flag) //
{
    if(node == NULL){
        node = GetNewNode(val);
        *flag = 1;                  //用来判断插入是否成功
        return node;
    }
        
    if(node->data == val)
        return node;
    else if(node ->data>val){
        node->lchild=insert_binary_node(node->lchild, val,flag);
    }
    else {
        node->rchild=insert_binary_node(node->rchild, val,flag);
    }
    return node;
}

void insert_binary(Tree *tree,int val)
{
    if(tree == NULL) return ;
    int flag = 0;
    tree->root = insert_binary_node(tree->root, val,&flag);
    tree->n += flag;    //通过flag来计数节点的个数
    return;
}

void Pre_Out_Node(Node *node) //这里的前序遍历也是一种迭代的形式，也满足入栈出栈的一种思想
{
    if(node == NULL)
        return;
    printf("%d ", node->data);
    Pre_Out_Node(node->lchild);
    Pre_Out_Node(node->rchild);
    return;
}


void Pre_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("Pre_Out: ");
    Pre_Out_Node(tree->root);
    printf("\n");
    return;
}

void in_Out_Node(Node *node) //这里的中序遍历可以将二叉树里的数据按从小到大输出
{
    if(node == NULL)
        return;
    
    in_Out_Node(node->lchild);
    printf("%d ", node->data);
    in_Out_Node(node->rchild);
    return;
}


void in_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("in_Out: ");
    in_Out_Node(tree->root);
    printf("\n");
    return;
}


void rin_Out_Node(Node *node) //这里的中序遍历改版可以将二叉树里的数据按从大到小输出
{
    if(node == NULL)
        return;
    
    rin_Out_Node(node->rchild);
    printf("%d ", node->data);
    rin_Out_Node(node->lchild);
    return;
}


void rin_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("in_Out: ");
    rin_Out_Node(tree->root);
    printf("\n");
    return;
}

void post_Out_Node(Node *node) //这里的后序遍历
{
    if(node == NULL)
        return;
    
    post_Out_Node(node->lchild);
    
    post_Out_Node(node->rchild);
    printf("%d ", node->data);
    return;
}


void post_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("post_Out: ");
    post_Out_Node(tree->root);
    printf("\n");
    return;
}

void Clear_Node(Node *node)
{
    if (node == NULL)
        return;
    // Clear_Node(node->lchild);
    // free(node);
    // Clear_Node(node->rchild);
    // free(node);
    /*不能以上面那种方式进行删除，上面的子节点没有释放完毕就开始释放当前节点会造成内存泄露
      下面这种左边和右边都迭代到底然后在释放迭代到底的那个节点，这样可以保证释放的节点都是当前最底部的
      不会造成内存泄露*/
    Clear_Node(node->lchild);  
    Clear_Node(node->rchild);
    free(node);
}

void Clear_Tree(Tree *tree)
{
    if(tree == NULL)
        return;
    Clear_Node(tree->root);
    free(tree);
}

void OutNode_bin_table(Node *root)
{
    if(root == NULL)
        return;
    printf("%d ", root->data);
    if(root->lchild == NULL && root->rchild == NULL)
        return;
    printf("(");
    OutNode_bin_table(root->lchild);
    printf(",");
    OutNode_bin_table(root->rchild);
    printf(")");
    return;
}

void Out_bin_table(Tree *tree)
{
    if(tree == NULL)
        return;
    printf("tree(%d) :", tree->n);
    OutNode_bin_table(tree->root);
    printf("\n");
    return;
}

int main(int argc, char const *argv[])
{
    srand(time(0));
    Tree *tree = GetNewTree();
    #define max_op 10
    for (int i = 0; i < max_op; i++)
    {
        int val = rand() % 100;
        insert_binary(tree, val);
        Out_bin_table(tree);
    }
    Pre_Out(tree);
    in_Out(tree);
    rin_Out(tree);
#undef max_op
    Clear_Tree(tree);
    return 0;
}

广义表转二叉树

/***********************************
广义表转二叉树 

需要栈来匹配根节点和左右子节点，用了栈的递归思想，先找到最内层最里面的子节点然后在往外扩
用二叉树来存储节点数据
这里只能转换用字符表示的广义表用数字的还不行


 ***********************************/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include<string.h>

typedef struct Node
{
    int data;
    struct Node *lchild, *rchild;
}Node;

typedef struct Tree
{
    Node *root;
    int n;
}Tree;

typedef struct Stack {
    Node **data;                    //指向堆中数组的指针，但是因为这里的数组是存储地址的所有是两个*
    int size, top;               //size是数组的大小，top为数组中存储的最新数据的下标
} Stack;



Tree *GetNewTree()
{
    Tree *p = (Tree *)malloc(sizeof(Tree));
    p->root = NULL;
    p->n = 0;
    return p;
}

Node *GetNewNode(int val)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->lchild = p->rchild = NULL;
    return p;
}

Stack *init(int n) {
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (Node **)malloc(sizeof(Node *) * n);
    s->size = n;
    s->top = -1;
    return s;
}

Node* top(Stack *s) {         //访问数组中top下标所在的数据，就是栈顶的最新数据
    return s->data[s->top];
}

int empty(Stack *s) {
    return s->top == -1;
}

int push(Stack *s, Node* val) { 
    if (s == NULL) return 0;
    if (s->top == s->size - 1) return 0;   //
    s->data[++(s->top)] = val;
    return 1;
}

int pop(Stack *s) {
    if (s == NULL) return 0;
    if (empty(s)) return 0;
    s->top -= 1;
    return 1;
}

void clear(Stack *s) {
    if (s == NULL) return ;
    free(s->data);
    free(s);
    return ;
}

void Clear_Node(Node *node)
{
    if (node == NULL)
        return;
    // Clear_Node(node->lchild);
    // free(node);
    // Clear_Node(node->rchild);
    // free(node);
    /*不能以上面那种方式进行删除，上面的子节点没有释放完毕就开始释放当前节点会造成内存泄露
      下面这种左边和右边都迭代到底然后在释放迭代到底的那个节点，这样可以保证释放的节点都是当前最底部的
      不会造成内存泄露*/
    Clear_Node(node->lchild);  
    Clear_Node(node->rchild);
    free(node);
}

void Clear_Tree(Tree *tree)
{
    if(tree == NULL)
        return;
    Clear_Node(tree->root);
    free(tree);
}

Node* build(const char *str,int *node_num)
{
    Stack *s = init(strlen(str));
    Node *temp = NULL, *p = NULL;
    int flag = 0;
    while (str[0])
    {
        switch (str[0])
        {
        case '(':
            push(s, temp);
            flag = 0;
            break;
        case ')':
            p = top(s);
            pop(s);
            break;
        case ',':
            flag = 1;
            break;
        case ' ':
            break;
        default:
            {
            temp = GetNewNode(str[0]);
            if (!empty(s) && flag == 0)
            {
                top(s)->lchild = temp;
            }else if (!empty(s) && flag == 1)
            {
                top(s)->rchild = temp;
            }
            ++(*node_num);
            }
            break;
        }
        ++str;
    }
    clear(s);   //出现A只有一个根节点的情况
    if (temp && !p)
        p = temp;
    return p;
}

void Pre_Out_Node(Node *node) //这里的前序遍历也是一种迭代的形式，也满足入栈出栈的一种思想
{
    if(node == NULL)
        return;
    printf("%c ", node->data);
    Pre_Out_Node(node->lchild);
    Pre_Out_Node(node->rchild);
    return;
}


void Pre_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("Pre_Out: ");
    Pre_Out_Node(tree->root);
    printf("\n");
    return;
}

void in_Out_Node(Node *node) //这里的中序遍历可以将二叉树里的数据按从小到大输出
{
    if(node == NULL)
        return;
    
    in_Out_Node(node->lchild);
    printf("%c ", node->data);
    in_Out_Node(node->rchild);
    return;
}


void in_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("in_Out: ");
    in_Out_Node(tree->root);
    printf("\n");
    return;
}


void rin_Out_Node(Node *node) //这里的中序遍历改版可以将二叉树里的数据按从大到小输出
{
    if(node == NULL)
        return;
    
    rin_Out_Node(node->rchild);
    printf("%d ", node->data);
    rin_Out_Node(node->lchild);
    return;
}


void rin_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("in_Out: ");
    rin_Out_Node(tree->root);
    printf("\n");
    return;
}

void post_Out_Node(Node *node) //这里的后序遍历
{
    if(node == NULL)
        return;
    
    post_Out_Node(node->lchild);
    
    post_Out_Node(node->rchild);
    printf("%c ", node->data);
    return;
}
void post_Out(Tree* tree)
{
    if(tree ==NULL)
        return;
    printf("post_Out: ");
    post_Out_Node(tree->root);
    printf("\n");
    return;
}

int main(int argc, char const *argv[])
{
    char str[1000] = {0};
    int node_num = 0;
    scanf("%[^\n]s", str);
    printf("%s\n", str);
    for (int i = 0; i < 10; i++)
    {
        printf("%c\n", str[i]);
    }
    
    Tree *tree = GetNewTree();
    tree->root = build(str, &node_num);
    tree->n = node_num;
    Pre_Out(tree);
    in_Out(tree);
    post_Out(tree);
    Clear_Tree(tree);
    return 0;
}

练习题

在这里插入图片描述

GK小卜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的存储方式
m0_58177783的博客
11-03 501
顺序存储法： 实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素。 //二叉树顺序存储表示 #define MAXSIZE 100 Typedef TElemType SqBiTree[MAXSIZE] SqBiTree bt; 缺点： 存在空间浪费 特点： 结点间关系蕴含在其存储位置中 适用于存满二叉树和完全二叉树。 二叉树的链式存储结构： 二叉链表： typedef struct BiNOde{ TElemTyoe data; struct BiNode *
二叉查询树的保存和读取
Yuwen's Hero
08-17 1602
问题： 把一个二叉查询树保存到一个文件，然后通过这个文件把这个二叉查询树还原出来。 我们使用pre-order遍历把一个二叉查询树保存，原因是只有pre-order遍历是从root开始保存，这样，当我们读取的时候，才能够把那个值放在root。 这里我用print来表示保存。 public void preOrderWrite(Node root) { if (
数据结构:二叉树存储结构及实现
m0_57781912的博客
09-12 1678
二叉树顺序结构存储以及堆的创建
Day10——二叉树存储
Z__XY_的博客
04-09 1954
为什么引用 (指针) 是无法存储到文件里面呢？ 因为文件都是存储在磁盘上的，也就是外存，但我们在执行程序的时候，是需要将程序对应的进程加载到内存中，并且进程在内存中的地址不是固定的，这表明我们不能保证保存在文件中的指针在下次运行时所指向的内容还是我们之前所指向的内容。 所以我们该怎么保存二叉树呢？ 保存结点之间的逻辑关系，就像数组一样，虽然每次运行时内存地址不一样，但它们的逻辑关系是确定的，我们就可以根据元素之间的逻辑关系和运行时的数组首地址来保存和访问各个元素。 介绍两种特殊的二叉树： 满二叉树：树中的每
VC、C++保存二叉树在文件中然后读出来
qq_31032765的博客
03-07 1121
只要给每个节点按照它在二叉树中的位置给与其一个唯一的编号，那么只要记录每个节点的编号和相关信息，就能够记录一整棵二叉树 编号方式: 用n(x)表示节点x的编号 1、如果x是根节点，那么n(x)=1 2、如果x不是根节点，那么x有亲节点p;如果x是p的左子节点，那么n(x)=n(p)*2，否则n(x)=n(p)*2+1 在文件中记录格式: 节点总数 节点1编号 节点1信息 节
二叉树构造与遍历的C程序实现代码
冒大烟的羊肉串的专栏
08-26 1156
#include #include typedef struct Node {     char value;     struct Node *leftChild;     struct Node *rightChild; }TreeNode;
Objective-C实现二叉树遍历算法（源代码）
04-30
本文展示了如何在Objective-C中实现一个简单的二叉树算法。首先，定义了一个二叉树节点的类BinaryTreeNode，用于存储数据和指向左右子节点的指针。接着，定义了一个二叉树类BinaryTree，该类包含一个根节点指针，并...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树遍历有四种常见的方法：先序遍历、中序...
二叉树的遍历实验报告.pdf
11-11
总结，二叉树遍历是理解和操作二叉树的关键步骤，通过递归实现的先序、中序、后序遍历提供了灵活的访问和处理节点的方法。掌握这些遍历技巧对于解决复杂问题至关重要，特别是在实际编程应用中，如搜索算法、文件系统...
C语言实现二叉树遍历
06-03
在计算机科学中，二叉树是一种特殊的图结构，其中每个节点最多有...在给定的项目中，"C语言实现二叉树遍历"不仅包含了上述四种遍历方式，还有递归和非递归两种实现，这对于深入理解二叉树遍历的原理和技巧非常有帮助。
二叉树的存储及其遍历.txt
12-24
二叉树的存储及其遍历，实验时做的。希望对大家有帮助
Python实现二叉树结构与进行二叉树遍历的方法详解
09-21
二叉树遍历主要有四种方式：前序遍历、中序遍历、后序遍历和层次遍历。 1. **前序遍历**：先访问根节点，然后遍历左子树，最后遍历右子树。 2. **中序遍历**：先遍历左子树，然后访问根节点，最后遍历右子树。 3. *...
C语言实现二叉树的遍历（数据结构）
热门推荐
Eli_Code
10-26 2万+
二叉树的定义 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树 二叉树的性质 二叉树遍历 二叉树有三种遍历方式，分别为先序遍历、中序遍历、后序遍历 先序遍历： （1）先访问根节点。 （2）再访问左子树。 （3）最后访问右子树。 中序遍历： （1）先访问左子树。 .
二叉树的前序，中序，后序遍历的简单理解
Alexander的博客
10-31 3991
0.遍历顺序 对于二叉树，其实遍历顺序一共有6种，基于有左子树，右子树，根这三个因素，即排列组合有3 * 2 * 1=6种结合顺序，不过因为算法思想是一样的，就没有必要把左右子树的先后再分开讨论，所以普遍认为左子树优先右子树。 1.命名含义 前序，中序，后序的命名，其实就是取决于遍历根节点的先后，比如DLR/前序遍历就是最先遍历根节点； LDR/中序遍历就是第二遍历根节点； LRD/后序遍历就...
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 289
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1029
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 220
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 851
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
用C语言实现二叉树遍历，完整代码
05-30
下面是使用C语言实现二叉树遍历的完整代码，包括二叉树结构体定义、创建二叉树、三种遍历方式的递归实现和非递归实现。 ```c #include #include #include #include // 二叉树结构体 typedef struct TreeNode {...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值