二叉树的实现（C语言数据结构）

已于 2022-05-25 19:27:47 修改
阅读量9.6k 收藏 143
点赞数 28
分类专栏： 数据结构(C/C++) 文章标签： 数据结构 c语言 算法
于 2022-05-23 23:15:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62684026/article/details/124936031
版权

目录

一、以下是我们需要实现的功能

二、以下是我们具体功能的实现

1.创建新的结点

2.通过数组生成二叉树

 3.先序遍历

4.中序遍历

5.后序遍历 

 6.层序遍历

7.计算二叉树的结点个数

8.查找指定值为x的结点

9.查找第K层的结点个数

10.统计二叉树叶子结点的个数

11.判断是否为完全二叉树

12.二叉树的销毁

13.求二叉树的高度

14.汇总

三、测试代码

一、以下是我们需要实现的功能

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef char BTDataType;

typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
}BTNode;

BTNode* BuyNode(BTDataType x);

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestroy(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

二、以下是我们具体功能的实现

1.创建新的结点

在下面的代码中，我们将调用我们的创建新的结点来快速创建结点。

TNode* BuyNode(BTDataType x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);

    node->_data = x;
    node->_left = NULL;
    node->_right = NULL;

    return node;
}

2.通过数组生成二叉树

BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
//这里我们的a为我们的数组
//n为我们数组的最大长度
//pi为我们遍历数组的指针。
//这里我们使用'#'来表示NULL
//当我们所指向的位置的元素为#或者我们的指针已经超出了数组的范围的时候，我们就需要返回NULL
//并且将我们的指针后移。
    if(a[*pi] == '#' || *pi >= n)
    {
        printf("NULL ");
        (*pi)++;
        return NULL;
    }
//创建一个新的二叉树的结点
    BTNode *dst= BuyNode(a[*pi]);
    printf("%c ",dst->_data);
    (*pi)++;
//将我们之前开创的结点的左右指针指向数组中所对应的结点
//如果我们的对应数组中的数据不为空的话，我们的左右指针都会指向新的对应的结点
//如果我们的结点为空的话，我们会得到的返回值为NULL，
    dst->_left = BinaryTreeCreate(a,n,pi);
    dst->_right = BinaryTreeCreate(a,n,pi);

    return dst;
}

 就如我们在下面的代码中的数组，我们按照上面先序遍历的代码的描述，我们所创建出来的就是这样一棵二叉树

 3.先序遍历

先序遍历就是先遍历我们的根节点，然后遍历我们左子树，然后遍历我们的右子树。

//先序遍历
void BinaryTreePrevOrder(BTNode* root)
{
//如果我们根节点的等于NULL，我们就直接返回上一层递归
    if(root == NULL)
    {
        return;
    }
//将我们当前结点中的数据打印出来
    printf("%c ",root->_data);
//遍历我们的左树
    BinaryTreePrevOrder(root->_left);
//遍历我们的右树
    BinaryTreePrevOrder(root->_right);
}

我们上面代码进行先序遍历所生成的序列是这样的

 

4.中序遍历

中序遍历就是先读取我们左子树中的元素，再读取我们根节点的元素，最后再读取右子树中的元素。

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    BinaryTreeInOrder(root->_left);
    printf("%c ",root->_data);
    BinaryTreeInOrder(root->_right);
}

 

5.后序遍历 

后序遍历就是先遍历我们的左子树，再遍历我们右子树，最后遍历我们的根节点

void BinaryTreePostOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    BinaryTreePostOrder(root->_left);
    BinaryTreePostOrder(root->_right);
    printf("%c ",root->_data);
}

从下面的顺序中，我们发现我们最后才遍历了根节点 

 

 6.层序遍历

层序遍历就是先将我们二叉树的根节点入队，然后再将我们根节点的左右指针所指向的结点入队，然后将我们队首的元素出队。

这里我们需要用到一个队列，具体的队列的代码我们在下面的汇总代码中将会给出。

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
//创建我们的队列
    Queue q;
//初始化队列
    QueueInit(&q);
    assert(root);
//将我们的根节点入队列
    QueuePush(&q, root);
//如果我们的栈空间不为空的话就继续我们的循环
    while(!QueueEmpty(&q))
    {
//创建一个临时变量结点获得我们队列头的结点
        BTNode *temp= QueueFront(&q);
//将我们队列头的数据打印
        printf("%c ",temp->_data);
//将我们队列头的左右指针所对应的结点入队列
        if(temp->_left)
        {
            QueuePush(&q,temp->_left);
        }
        if(temp->_right)
        {
            QueuePush(&q,temp->_right);
        }
//将我们队头的结点出队
        QueuePop(&q);
    }
//销毁我们的队伍
    QueueDestory(&q);
}

7.计算二叉树的结点个数

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
//如果我们当前的结点为空，也就是说我们已经到了叶子结点的左右结点，也就是没有结点
//所以我们需要返回0
    if(root==NULL)
    {
        return 0;
    }
//如果我们当前的结点的左指针和右指针都是空的话，也就是说这是我们的叶子结点
//就返回1，也就是只有一个结点。
    if(root->_left==NULL&&root->_right==NULL)
    {
        return 1;
    }
//使用递归遍历我们的二叉树，即分别统计我们左子树中的结点个数再加上右子树中的结点个数再加上1
//因为我们需要将我们当前所指的结点算上。
    return BinaryTreeSize(root->_left)+BinaryTreeSize(root->_right)+1;
}

8.查找指定值为x的结点

这里我们的目的是找到第一个指定值为x的结点，也就是说采用先序遍历是最佳的方法。因为先序遍历会首先找到所对应的结点然后将其返回，但是我们如果采用其他的遍历方式，由于先找到的不是根节点的元素，而是分别以左中右，和左右中的顺序来遍历，就会当根结点为我们的1目标结点时错过我们的根节点。

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->_data==x)
    {
        return root;
    }
    BinaryTreeFind(root->_left, x);
    BinaryTreeFind(root->_right,x);
}

9.查找第K层的结点个数

查找第k层，我们将我们的问题化为小问题，也就是我们第一层的结点需要往下找k-1层，第二层的结点需要往下找k-2层，以此类推，只有当我们的k为1的时候返回的就是我们需要找的k层的结点的个数的总和。

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if(root==NULL)
    {
        return 0;
    }
    if(k==1)
    {
        return 1;
    }
//分别遍历我们的左右子树，并且将我们的k的参数--,当我们的k为1时，就到达了我们所想要查找对应的层。
    return BinaryTreeLevelKSize(root->_left, k-1)+BinaryTreeLevelKSize(root->_right, k-1);
}

10.统计二叉树叶子结点的个数

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
//如果我们的结点的左右指针全部都为空，那就是我们的叶子结点
    if(root->_left==NULL&&root->_right==NULL)
    {
        return 1;
    }
//返回我们左子树中的叶子结点和右子树中的叶子结点之和
    return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
}

11.判断是否为完全二叉树

这里我们的主要思路就是通过采取类似层序遍历的方法，找到我们叶子结点的下一层结点。

如果我们的二叉树为一颗完全二叉树，我们叶子结点的下一层结点中的全部结点应该都是null，如果不是的话，就不是完全二叉树。

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
//如果我们的根节点是NULL就返回1表示是一棵完全二叉树
    if(root==NULL)
    {
        return 1;
    }
//创建并且初始化我们的队列
    Queue q;
    QueueInit(&q);
//将我们的根节点入队
    QueuePush(&q,root);
//这里与我们层序遍历的思路相同，但是我们需要找到我们层序遍历中的最后一层
//也就是我们叶子结点的下一层
//如果我们的二叉树是一棵完全二叉树，我们的叶子结点的下一层应该全部都是NULL
//在下面的第一个will中我们先找到我们叶子结点的下一层的第一个NULL结点，然后跳出循环
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp==NULL)
        {
            break;
        }
        QueuePush(&q,temp->_left);
        QueuePush(&q,temp->_right);

    }
//在我们的第二个节点中，我们将继续遍历我们的栈，如果我们当前栈中的全部全部结点都是NULL，
//那我们的二叉树就是完全二叉树，不然就不是
//如果是完全二叉树的话，我们就返回1，不是的话我们就返回0
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp!=NULL)
        {
            printf("不是完全二叉树\n");
            return 0;
        }
    }
    printf("是完全二叉树\n");
    return 1;
}

对于我们上面所创建的二叉树，我们可以从下面的图中看出，我们经过层次遍历之后，我们找到了叶子结点的下一层结点，当我们读取到null的时候，我们跳出了第一个循环，进入第二个循环，在这第二个循环中，如果我们此时队列中剩余的数据全部都是NULL，我们就能判断这是一棵完全二叉树，但是在下面的图中，我们发现我们在读取到了三个null之后，我们读取到了H这个不为null的值，所以我们可以判断我们当前的这棵二叉树不是完全二叉树。 

 

 

12.二叉树的销毁

对于二叉树的销毁，采取后续遍历的形式，先找到我们二叉树中的左子树和右子树中的底层的结点，（这里的底层指的是叶子结点那一层），然后将我们的叶子结点分别释放空间，再一层层返回调用，自下而逐渐销毁。

// 二叉树销毁
void BinaryTreeDestroy(BTNode** root)
{
    if(*root==NULL)
    {
        return;
    }
    BinaryTreeDestroy(&((*root)->_left));
    BinaryTreeDestroy(&((*root)->_right));
    free(*root);
    *root=NULL;
    return;
}

13.求二叉树的高度

int BinaryTreeHeight(BTNode*root)
{
//如果我们的根节点为空的话，我们就直接返回
    if(root==NULL)
    {
        return 0;
    }
//如果我们找到了我们的叶子结点，我们就返回1
    if(root->_right==NULL&&root->_left==NULL)
    {
        return 1;
    }
//递归调用，如果我们的左子树的高度大于右子树的高度，我们返回的数据就是左子树的高度再加1
//这里的+1就是我们当前层的结点
//如果我们的右子树的高度大于我们左子树的高度，我们返回的数据就是右子树的高度再加1
    return (BinaryTreeHeight(root->_left)>=BinaryTreeHeight(root->_right) ? BinaryTreeHeight(root->_left)+1 :BinaryTreeHeight(root->_right)+1);
}

14.汇总

以下是我们写在Btree.c中的全部代码（含有二叉树加上队列的代码）

#include "Btree.h"

BTNode* BuyNode(BTDataType x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);

    node->_data = x;
    node->_left = NULL;
    node->_right = NULL;

    return node;
}


BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
    if(a[*pi] == '#' || *pi >= n)
    {
        printf("NULL ");
        (*pi)++;
        return NULL;
    }
    BTNode *dst= BuyNode(a[*pi]);
    printf("%c ",dst->_data);
    (*pi)++;

    dst->_left = BinaryTreeCreate(a,n,pi);
    dst->_right = BinaryTreeCreate(a,n,pi);

    return dst;
}


//先序遍历
void BinaryTreePrevOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }

    printf("%c ",root->_data);
    BinaryTreePrevOrder(root->_left);
    BinaryTreePrevOrder(root->_right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
    BinaryTreePrevOrder(root->_left);
    if(root == NULL)
    {
        return;
    }

    printf("%c ",root->_data);
    BinaryTreePrevOrder(root->_right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
    BinaryTreePrevOrder(root->_left);
    BinaryTreePrevOrder(root->_right);
    if(root == NULL)
    {
        return;
    }

    printf("%c ",root->_data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
    Queue q;
    QueueInit(&q);
    assert(root);
    QueuePush(&q, root);
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        printf("%c ",temp->_data);
        if(temp->_left)
        {
            QueuePush(&q,temp->_left);
        }
        if(temp->_right)
        {
            QueuePush(&q,temp->_right);
        }

        QueuePop(&q);
    }
    QueueDestory(&q);
}

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->_left==NULL&&root->_right==NULL)
    {
        return 1;
    }
    return BinaryTreeSize(root->_left)+BinaryTreeSize(root->_right)+1;
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->_data==x)
    {
        return root;
    }
    BinaryTreeFind(root->_left, x);
    BinaryTreeFind(root->_right,x);
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if(root==NULL)
    {
        return 0;
    }
    if(k==1)
    {
        return 1;
    }
    return BinaryTreeLevelKSize(root->_left, k-1)+BinaryTreeLevelKSize(root->_right, k-1);
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->_left==NULL&&root->_right==NULL)
    {
        return 1;
    }
    return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
    if(root==NULL)
    {
        return 1;
    }
    Queue q;
    QueueInit(&q);
    QueuePush(&q,root);
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp==NULL)
        {
            break;
        }
        QueuePush(&q,temp->_left);
        QueuePush(&q,temp->_right);

    }
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp!=NULL)
        {
            printf("不是完全二叉树\n");
            return 0;
        }
    }
    printf("是完全二叉树\n");
    return 1;
}
// 二叉树销毁
void BinaryTreeDestroy(BTNode** root)
{
    if(root==NULL)
    {
        return ;
    }
    if(*root==NULL)
    {
        return;
    }
    BinaryTreeDestroy(&((*root)->_left));
    BinaryTreeDestroy(&((*root)->_right));
    free(*root);
    *root=NULL;
    return;
}

//求二叉树的高度
int BinaryTreeHeight(BTNode*root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->_right==NULL&&root->_left==NULL)
    {
        return 1;
    }
    return (BinaryTreeHeight(root->_left)>=BinaryTreeHeight(root->_right) ? BinaryTreeHeight(root->_left)+1 :BinaryTreeHeight(root->_right)+1);
}

//队列的创建
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }

    pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    assert(newnode);

    newnode->data = x;
    newnode->next = NULL;

    if (pq->tail == NULL)
    {
        assert(pq->head == NULL);
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
}

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(pq->head && pq->tail);

    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }
}

bool QueueEmpty(Queue* pq)
{
    assert(pq);

    //return pq->head == NULL && pq->tail == NULL;
    return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    size_t size = 0;
    while (cur)
    {
        size++;
        cur = cur->next;
    }

    return size;
}

QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->head);

    return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->tail);

    return pq->tail->data;
}

以下是我们写在Btree.h中的全部代码（二叉树再加上队列的代码）

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef char BTDataType;

typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
}BTNode;

BTNode* BuyNode(BTDataType x);

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestroy(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);
//求二叉树的高度
int BinaryTreeHeight(BTNode* root);

typedef BTNode *QDataType;

typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;

    //size_t size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

三、测试代码

以下是我们写在test.c中的代码

#include"Btree.h"
int main() {
    char a[17]={'A','B','D','#','#','E','#','H','#','#','C','F','#','#','G','#','#'};
    int b=0;
    int *pi=&b;
    BTNode *Btree=BinaryTreeCreate(a, 16, pi);
    printf("\n");
//前序遍历
    BinaryTreePrevOrder(Btree);
    printf("\n");
//中序遍历
    BinaryTreeInOrder(Btree);
    printf("\n");
//后序遍历
    BinaryTreePostOrder(Btree);
    printf("\n");
    //乘次遍历
    BinaryTreeLevelOrder(Btree);
    printf("\n");

    int number=BinaryTreeSize(Btree);
    printf("%d",number);
    printf("\n");
    //查找为x的结点
    BTNode *find=BinaryTreeFind(Btree, 'A');
    printf("%c\n",find->_data);

    //查询第k层的结点个数
    int w=BinaryTreeLevelKSize(Btree, 3);
    printf("%d\n",w);

    //查询叶子结点的个数
    int count=BinaryTreeLeafSize(Btree);
    printf("%d\n",count);

//判断当前是否为一棵完全二叉树
    int r=BinaryTreeComplete(Btree);

    //求二叉树的高度
    int x=BinaryTreeHeight(Btree);
    printf("二叉树的高度是%d\n",x);
//    int c=fmax(2,1);
//    printf("%d\n",c);
//销毁二叉树
    BinaryTreeDestroy(&Btree);
    return 0;
}

以下是我们代码的输出结果

​​​​​​​

桜キャンドル淵
关注
专栏目录
二叉树创建C语言实现
02-24
通过链式存储结构实现二叉树的创建，包含如下操作： 1. 创建树； 2. 销毁树； 3. 清空树； 4. 插入结点； 5. 删除结点； 6. 获取结点； 7. 获取根结点； 8. 获取树的结点数； 9. 获取树的高度； 10. 获取树的度； 11. 显示二叉树。
二叉树C语言实现
02-28
二叉树的实现，创建，遍历（先序、中序、后序）添加，修改，删除
C语言写二叉树
jakelihua
11-28 1696
简介：本文是博主当初学习阶段，用C语言实现的二叉树代码。
二叉树的C语言实现
m0_49151977的博客
08-10 313
本文使用C语言实现了普通二叉树的创建、遍历、深度等一系列算法。欢迎关注个人博客：https://guotianyu-2020.github.io。 1.代码部分 首先进行二叉树结构体的定义： typedef struct BiNode { char data; struct BiNode* lchild, * rchild; }BiNode, *BiTree; 在二叉树的非递归算法中，使用到了栈与队列，其定义如下 typedef struct { BiTree base; BiTree top.
C语言实现二叉树
weixin_30908649的博客
09-05 102
二叉树的重要性就不用多说啦； 我以前也学习过，但是一直没有总结； 网上找到的例子，要么是理论一大堆，然后是伪代码实现； 要么是复杂的代码，没有什么解释； 最终，还是靠FQ找到一些好的文章，参考地址我会在See Also部分给大家贴出来 Problem 假设我们要生成的二叉树如下图； Solution 显然，我们需要在节点保存的数据只有一个整数； struct ...
c语言的二叉树的创建
被遗弃的庸才博客
05-04 1539
创建二叉树和三种输出方法
C语言数据结构实现二叉树的建立与遍历.cpp
04-18
C语言数据结构实现二叉树的建立与遍历.cpp
数据结构第五章-树与二叉树 二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
exp3-BinaryTree.zip_二叉树的C语言实现_数据结构
09-20
二叉树是一种重要的数据结构，它在计算机科学中有着广泛的应用，例如文件...通过实践和理解二叉树及其线索化，你不仅能提升C语言编程能力，还能深化对数据结构和算法的理解，这对于成为一名优秀的IT专业人员至关重要。
数据结构二叉树，c语言简单实现
01-12
数据结构中的二叉树是一种非线性数据结构，它由n（n>=1）个有限节点组成，这些节点通过边连接形成一个具有层次关系的集合。每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的概念在计算机科学中广泛...
二叉树源码(C语言实现)
01-17
二叉树的C语言实现版本
二叉树实现代码
07-02
有关二叉树的代码，本例具有全面性，而且绝对经典！
二叉树的建立（C语言）
12-31
数据结构二叉树建立的实现程序，任意输入三个字母以+双空格+一个字母+双空格+一个字母+双空格+回车。
数据结构之线索二叉树-C语言实现.pdf
01-15
这种数据结构在计算机科学中，尤其是在数据结构的学习和实际应用中具有重要意义，因为它能够简化对非空二叉树的遍历操作。 在二叉链表中，每个结点通常包含三个域：左孩子指针、右孩子指针和一个标志位。线索二叉树...
c语言实现二叉树（源码）
weixin_44606789的博客
10-16 1837
#include <stdio.h> #include <stdlib.h> //定义二叉树的结构 typedef struct binary_tree { int data; // 节点保存的数据 binary_tree* left; // 定义左节点指针 binary_tree* right; // 定义右节点指针 }node; //初始化二叉树 void insert(node** tree, int gain) //指向指针变量的指针，结果...
C语言二叉树代码实现
热门推荐
许新天的博客
07-14 3万+
btree.h  //二叉树头文件，用于声明数据类型和相关函数#ifndef __BTREE_H__ #define __BTREE_H__ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef char dataype_bt; //声明二叉树中存放的数据类型，便于后续更改 ...
数据结构--二叉树（代码实现）
cat_eat_fish
11-16 874
一、概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒。 二、存储结构、 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。 三、二叉树的性质 若规定根节点的层
【数据结构】二叉树的构建(C语言实现)
weixin_64214213的博客
08-25 1万+
二叉树的构建
数据结构：一般二叉树的C语言实现
"一般二叉树-c版本数据结构（严老师）" ...总结来说，"一般二叉树-c版本数据结构（严老师）"这个主题涵盖了数据结构基础，特别是二叉树的理论和C语言实现。理解和掌握这些概念对于编写高效算法和设计复杂系统至关重要。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

桜キャンドル淵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值