1. Toy模板网首页
  2. > Toy博客

【C语言】数据结构——链式二叉树实例探究

9月前 作者：流浪者与猴 分类：Toy博客 阅读(38) 违法举报

这篇具有很好参考价值的文章主要介绍了【C语言】数据结构——链式二叉树实例探究。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

💗个人主页💗
⭐个人专栏——数据结构学习⭐
💫点击关注🤩一起学习C语言💯💫

导读：

我们在前面学习了单链表，顺序表，栈和队列，小堆。
今天我们来学习链式二叉树
关注博主或是订阅专栏，掌握第一消息。

1. 链式二叉树的概念和结构

链式二叉树（Linked Binary Tree）是一种基于链表实现的二叉树结构。在链式二叉树中，每个节点由三个部分组成：数据、左子节点和右子节点。
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

1.1 链式二叉树的特点

链式二叉树的特点包括：

  1. 每个节点都有一个数据项，可以是任意类型的数据。
  2. 每个节点都有一个左子节点和一个右子节点。如果某个节点没有左子节点或右子节点，对应的子节点指针就为空。
  3. 子节点可以是空的，也可以是另一个链式二叉树的根节点。这就构成了二叉树的递归结构。

链式二叉树的优点是可以动态地插入和删除节点，不需要预先指定树的大小。
同时，链式二叉树的节点可以随意分配在内存中，不需要连续的存储空间。
缺点是相对于数组实现的二叉树，链式二叉树需要额外的指针来连接节点，因此会占用更多的内存空间。

1.2 链式二叉树的遍历

链式二叉树的遍历方式有三种：前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点，然后按照左子树、右子树的顺序遍历；
中序遍历先访问左子树，然后访问根节点，最后访问右子树；
后序遍历先访问左子树，然后访问右子树，最后访问根节点。

2. 二叉树的代码实现

2.1 创建二叉树

我们先创建一个六个节点的二叉树


typedef int BTDataType;
//typedef char BTDataType;

typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}TreeNode;

//开辟空间并赋值
TreeNode* BuyTreeNode(int x)
{
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    assert(node);
    node->data = x;
    node->left = NULL;
    node->right = NULL;
    return node;
}
TreeNode* CreateTree()
{
    TreeNode* node1 = BuyTreeNode(7);
    TreeNode* node2 = BuyTreeNode(9);
    TreeNode* node3 = BuyTreeNode(30);
    TreeNode* node4 = BuyTreeNode(25);
    TreeNode* node5 = BuyTreeNode(66);
    TreeNode* node6 = BuyTreeNode(88);
    node1->left = node2;
    node1->right = node4;
    node2->left = node3;
    node4->left = node5;
    node4->right = node6;
    return node1;
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.2 前序遍历

前序遍历：访问根结点的操作发生在遍历其左右子树之前。
**注意：**左节点全部访问完之后才访问右节点。
遇到NULL，则返回，否则继续调用，直到遇到NULL

//前序遍历
void PrevOrder(TreeNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return NULL;
    }
    //先访问根节点
    printf("%d ", root->data);
    //之后访问左节点和右节点
    PrevOrder(root->left);
    PrevOrder(root->right);
}

在这里我们把空值也打印了出来
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.3 中序遍历

中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
**注意：**是把一个节点的所有左子树访问完之后再去打印值，最后再访问右子树。

//中序遍历
void InOrder(TreeNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return NULL;
    }
    //访问完所有左子树后再打印值
    InOrder(root->left);
    printf("%d ", root->data);
    InOrder(root->right);
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.4 计算节点个数

计算链式二叉树的节点个数可以通过递归的方式实现。

  1. 若二叉树为空，则节点个数为0。
  2. 若二叉树不为空，则节点个数为根节点的个数加上左子树的节点个数和右子树的节点个数。
  3. 使用递归对左子树和右子树分别计算节点个数。
  4. 返回根节点的个数加上左子树和右子树的节点个数。
// 节点个数
int TreeSize(TreeNode* root)
{
    //如果为空返回0
    if (root == NULL)
    {
        return 0;
    }
    //不为空调用左右节点，每次调用都会加一
    return TreeSize(root->left)
        + TreeSize(root->right) + 1;
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.5 计算叶子节点的个数

叶子节点是指在树中没有子节点的节点，可以通过遍历树的方式来计算叶子节点的个数。
以下是计算叶子节点个数的递归算法：

  1. 如果树为空，则叶子节点个数为0。
  2. 如果树只有一个节点，则叶子节点个数为1。
  3. 否则，叶子节点个数等于左子树的叶子节点个数加上右子树的叶子节点个数。
// 叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    //如果该节点的左节点和右节点都为空
    if (!(root->left) && !(root->right))
    {
        return 1;
    }
    return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.6 计算树的高度

计算树的高度可以使用递归的方法来完成。一个树的高度可以定义为从根节点到最远叶子节点的边数。

// 树的高度
int TreeHight(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    //返回较大的一个
    return fmax(TreeHight(root->left), TreeHight(root->right)) + 1;
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.7 计算树第k层节点个数

树的第k层节点个数取决于树的结构，不同的树的第k层节点个数可能不同。一般情况下，树的第k层节点个数为k层的节点数减去k-1层的节点数。

int TreeLevelK(TreeNode* root, int k)
{
    assert(k > 0);
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    return TreeLevelK(root->left, k - 1) + 
        TreeLevelK(root->right, k - 1);
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
k=1时，说明到达了k层
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.8 二叉树查找值为x的节点

二叉树查找值为x的节点可以通过递归来实现，具体步骤如下：

  1. 如果当前节点为空，则返回空。
  2. 如果当前节点的值等于x，则返回当前节点。
  3. 如果该节点的值不等于x，递归在左子树中查找值为x的节点。
  4. 如果该左子树节点的值不等于x，递归在右子树中查找值为x的节点。
TreeNode* TreeFind(TreeNode* root, BTDataType x)
{
    if (root == NULL)
    {
        return NULL;
    }
    if (root->data == x)
    {
        return root;
    }
    //另设记录函数调用返回的值，再判断是否为kong
    TreeNode* ret1 = TreeFind(root->left, x);
    if (ret1)
    {
        return ret1;
    }
    TreeNode* ret2 = TreeFind(root->right, x);
    if (ret2)
    {
        return ret2;
    }
    return NULL;
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.9 通过前序遍历的数组构建二叉树

通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树，通过遍历我们要建立如下效果：
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
TreeNode* TreeCreate(char* a, int* pi)
{
    if (a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    if (root == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    root->data = a[(*pi)++];
    root->left = TreeCreate(a, pi);
    root->right = TreeCreate(a, pi);
    return root;
}
int main()
{
    char arr[] = "ABD##E#H##CF##G##";
    int i = 0;
    TreeNode* rootstr = TreeCreate(arr, &i);
    return 0;
}

2.10 层序遍历

链式二叉树的层序遍历可以通过使用队列来实现。具体步骤如下：

  1. 首先，将根节点入队。

  2. 进入循环，直到队列为空。

    • 从队列中取出一个节点，并将其值输出。
    • 如果该节点有左子节点，则将左子节点入队。
    • 如果该节点有右子节点，则将右子节点入队。

  3. 循环结束后，层序遍历完成。

//层序遍历
void LevelOrder(TreeNode* root)
{
    QNode q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    int levelSize = 1;
    while (!QueueEmpty(&q))
    {
        while (levelSize--)
        {
            TreeNode* front = QueueFront(&q);
            QueuePop(&q);
            printf("%c ", front->data);
            if (front->left)
            {
                QueuePush(&q, front->left);
            }
            if (front->right)
            {
                QueuePush(&q, front->right);
            }
        }
        printf("\n");
        levelSize = QueueSize(&q);
    }
    printf("\n");

    QueueDestroy(&q);
}

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言
【C语言】数据结构——链式二叉树实例探究,数据结构学习,c语言,数据结构,开发语言

2.11 判断一棵树是否是完全二叉树

完全二叉树是指除了最后一层外，其他层的节点都是满的，且最后一层的节点从左到右依次填满。因此，我们可以通过遍历树的节点来判断是否是完全二叉树。

  1. 使用层次遍历的方法遍历树的节点。
  2. 当遇到第一个为空的节点时，停止遍历。
  3. 继续遍历树的节点，如果还存在非空节点，那么该树不是完全二叉树。
  4. 如果遍历完所有节点，都没有发现非空节点，那么该树是完全二叉树。
//判断一棵树是否是完全二叉树
bool TreeComplete(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);

        if (front == NULL)
        {
            break;
        }

        QueuePush(&q, front->left);
        QueuePush(&q, front->right);
    }
    // 前面遇到空以后，后面还有非空就不是完全二叉树
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);

        if (front)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

2.12 二叉树销毁

需要把每一个节点都销毁，值得注意的是，要从最下层的节点开始销毁，而不是根节点

//二叉树销毁
void DestroyTree(TreeNode* root)
{
    if (root == NULL)
    {
        return NULL;
    }
    DestroyTree(root->left);
    DestroyTree(root->right);
    free(root);
}

3. 代码整理

该代码的层序遍历导入了我们之前写的队列文章来源地址https://www.toymoban.com/news/detail-764777.html

Queue.h

#define _CRT_SECURE_NO_WARNINGS 

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>


// 链式结构：表示队列 
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* pq);

// 销毁队列 
void QueueDestroy(Queue* pq);

// 队尾入队列 
void QueuePush(Queue* pq, QDataType x);

// 队头出队列
void QueuePop(Queue* pq);

// 获取队列头部元素 
QDataType QueueFront(Queue* pq);

// 获取队列队尾元素
QDataType QueueBack(Queue* pq);

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* pq);

// 获取队列中有效元素个数 
int QueueSize(Queue* pq);

Queue.c

#include "Queue.h"

// 初始化队列 
void QueueInit(Queue* pq)
{
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

// 销毁队列 
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead->next;
	while (cur)
	{
		free(pq->phead);
		pq->phead = cur;
		cur = cur->next;
	}
	cur = NULL;
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* pq, QDataType x)
{
	//开辟新空间
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

// 队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	QNode* tmp = pq->phead;
	pq->phead = pq->phead->next;
	free(tmp);
	tmp = NULL;
	if (pq->phead == NULL)
	{
		pq->ptail = NULL;
	}
	pq->size--;
}

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

// 检测队列是否为空，如果为空返回true，如果非空返回false 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

study.c

#include "Queue.h"

typedef int BTDataType;
//typedef char BTDataType;

typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}TreeNode;

TreeNode* BuyTreeNode(int x)
{
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    assert(node);
    node->data = x;
    node->left = NULL;
    node->right = NULL;
    return node;
}
TreeNode* CreateTree()
{
    TreeNode* node1 = BuyTreeNode(7);
    TreeNode* node2 = BuyTreeNode(9);
    TreeNode* node3 = BuyTreeNode(30);
    TreeNode* node4 = BuyTreeNode(25);
    TreeNode* node5 = BuyTreeNode(66);
    TreeNode* node6 = BuyTreeNode(88);
    node1->left = node2;
    node1->right = node4;
    node2->left = node3;
    node4->left = node5;
    node4->right = node6;
    return node1;
}

//前序遍历
void PrevOrder(TreeNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return NULL;
    }
    //先访问根节点
    printf("%d ", root->data);
    //之后访问左节点和右节点
    PrevOrder(root->left);
    PrevOrder(root->right);
}

//中序遍历
void InOrder(TreeNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return NULL;
    }
    //访问完所有左子树后再打印值
    InOrder(root->left);
    printf("%d ", root->data);
    InOrder(root->right);
}

// 节点个数
int TreeSize(TreeNode* root)
{
    //如果为空返回0
    if (root == NULL)
    {
        return 0;
    }
    //不为空调用左右节点，每次调用都会加一
    return TreeSize(root->left)
        + TreeSize(root->right) + 1;
}

// 叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    //如果该节点的左节点和右节点都为空
    if (!(root->left) && !(root->right))
    {
        return 1;
    }
    return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

// 树的高度
int TreeHight(TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    //返回较大的一个
    return fmax(TreeHight(root->left), TreeHight(root->right)) + 1;
}

//树第k层节点个数
int TreeLevelK(TreeNode* root, int k)
{
    assert(k > 0);
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    return TreeLevelK(root->left, k - 1) + 
        TreeLevelK(root->right, k - 1);
}

// 二叉树查找值为x的节点
TreeNode* TreeFind(TreeNode* root, BTDataType x)
{
    if (root == NULL)
    {
        return NULL;
    }
    if (root->data == x)
    {
        return root;
    }
    //另设记录函数调用返回的值，再判断是否为kong
    TreeNode* ret1 = TreeFind(root->left, x);
    if (ret1)
    {
        return ret1;
    }
    TreeNode* ret2 = TreeFind(root->right, x);
    if (ret2)
    {
        return ret2;
    }
    return NULL;
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
TreeNode* TreeCreate(char* a, int* pi)
{
    if (a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    if (root == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    root->data = a[(*pi)++];
    root->left = TreeCreate(a, pi);
    root->right = TreeCreate(a, pi);
    return root;
}

//二叉树销毁
void DestroyTree(TreeNode* root)
{
    if (root == NULL)
    {
        return NULL;
    }
    DestroyTree(root->left);
    DestroyTree(root->right);
    free(root);
}

//层序遍历
void LevelOrder(TreeNode* root)
{
    QNode q;
    //初始化队列
    QueueInit(&q);
    if (root)
    {
        //把根节点入队列
        QueuePush(&q, root);
    }
    //从1开始
    int levelSize = 1;
    while (!QueueEmpty(&q))
    {
        while (levelSize--)
        {
            TreeNode* front = QueueFront(&q);
            QueuePop(&q);
            printf("%c ", front->data);
            //入左子树和右子树
            if (front->left)
            {
                QueuePush(&q, front->left);
            }
            if (front->right)
            {
                QueuePush(&q, front->right);
            }
        }
        printf("\n");
        //获取队列有效数据个数
        levelSize = QueueSize(&q);
    }
    printf("\n");
    QueueDestroy(&q);
}

//判断一棵树是否是完全二叉树
bool TreeComplete(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    //遍历入队列
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
        {
            break;
        }
        QueuePush(&q, front->left);
        QueuePush(&q, front->right);
    }
    // 前面遇到空以后，后面还有非空就不是完全二叉树
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);

        if (front)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

void Test1()
{
    TreeNode* root = CreateTree();
    printf("前序遍历：\n");
    PrevOrder(root);
    printf("\n");
    printf("中序遍历：\n");
    InOrder(root);
    printf("\n");

    printf("节点个数：%d\n", TreeSize(root));
    printf("叶子节点的个数：%d\n", TreeLeafSize(root));
    printf("树的高度：%d\n", TreeHight(root));
    printf("树第k层节点个数：%d\n", TreeLevelK(root, 3));
    int x = 0;
    printf("请输入想要查找的x值：》");
    scanf("%d", &x);
    printf("查找值为x的节点: %p\n", TreeFind(root, x));
    bool ret = TreeComplete(root);
    if (ret)
    {
        printf("yes\n");
    }
    else
    {
        printf("no\n");
    }
}

void Test2()
{
    char arr[] = "ABD##E#H##CF##G##";
    int i = 0;
    TreeNode* rootstr = TreeCreate(arr, &i);
    LevelOrder(rootstr);
}
int main()
{
    //Test1();
    Test2();
    return 0;
}

到了这里，关于【C语言】数据结构——链式二叉树实例探究的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构】二叉树——链式结构

    【数据结构】二叉树——链式结构

    目录  一、前置声明 二、二叉树的遍历 2.1 前序、中序以及后序遍历 2.2 层序遍历 三、节点个数以及高度 3.1 节点个数 3.2 叶子节点个数 3.3 第k层节点个数 3.4 二叉树的高度/深度 3.5 查找值为x的节点 四、二叉树的创建和销毁 4.1 构建二叉树 4.2 二叉树销毁 4.3 判断二叉树

    2024年02月16日
    浏览(44)
  • 【数据结构】二叉树链式结构

    【数据结构】二叉树链式结构

    🚀write in front🚀 📜所属专栏：初阶数据结构 🛰️博客主页：睿睿的博客主页 🛰️代码仓库：🎉VS2022_C语言仓库 🎡您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！ 关注我，关注我，关注我 ， 你们将会看到更多的优质内容！！   在之前的二叉树的顺序结

    2024年02月03日
    浏览(39)
  • 【数据结构】二叉树(链式)

    【数据结构】二叉树(链式)

    😛作者：日出等日落 📘 专栏：数据结构           抱怨是一件最没意义的事情。如果实在难以忍受周围的环境，那就暗自努力练好本领，然后跳出那个圈子。 目录  🎄二叉树 ✔二叉树的结构：  ✔BuyNode(创建二叉树节点)： 🎄基本函数操作： ✔PreOrder(前序递归遍历)：

    2024年02月01日
    浏览(43)
  • 【数据结构】二叉树之链式结构

    【数据结构】二叉树之链式结构

    🔥 博客主页 ： 小羊失眠啦. 🎥 系列专栏 ： 《C语言》 《数据结构》 《Linux》 《Cpolar》 ❤️ 感谢大家点赞👍收藏⭐评论✍️ 在学习二叉树各种各样的操作前，我们先来回顾一下二叉树的概念： 二叉树是度不超过2的树，由根结点和左右2个子树组成，每个子树也可以看作

    2024年02月04日
    浏览(43)
  • 【数据结构】二叉树的链式结构

    【数据结构】二叉树的链式结构

    学习链式二叉树要知道三种遍历方式，便于对二叉树的节点以及左子树和右子树进行操作。 前序遍历：根、左子树、右子树 中序遍历：左子树、根、右子树 后序遍历：左子树、右子树、根 以下图为例： 得到的结果： 前序遍历：1 2 3 4 5 6 中序遍历：3 2 1 5 4 6 后序遍历：3 2

    2024年02月08日
    浏览(52)
  • 数据结构：二叉树的链式结构

    数据结构：二叉树的链式结构

    朋友们、伙计们，我们又见面了，本期来给大家解读一下链式二叉树的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ 数据结构与算法专栏 ：数据结构与算法 个  人  主  页 ：stackY、 C 语 言 专 栏 ：C语言：从入门到精通 目录 前言

    2024年02月07日
    浏览(56)
  • 数据结构——二叉树的链式结构

    数据结构——二叉树的链式结构

      个人主页 ： 日刷百题 系列专栏 ： 〖C语言小游戏〗〖Linux〗〖数据结构〗  〖C语言〗 🌎 欢迎各位 → 点赞 👍+ 收藏 ⭐️+ 留言 📝  ​ 这里我们使用先序遍历的思想来创建二叉树，这里的内容对于刚接触二叉树的朋友可能有些难理解，不妨先看完下面的二叉树各种遍历

    2024年02月05日
    浏览(43)
  • 【数据结构和算法】--- 二叉树（3）--二叉树链式结构的实现（1）

    【数据结构和算法】--- 二叉树（3）--二叉树链式结构的实现（1）

    在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，且为了方便后面的介绍，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研

    2024年01月25日
    浏览(59)
  • 【数据结构】二叉树的链式存储结构

    【数据结构】二叉树的链式存储结构

    前序遍历，又叫先根遍历。 遍历顺序：根 - 左子树 - 右子树 代码： 中序遍历，又叫中根遍历。 遍历顺序：左子树 - 根 - 右子树 代码 ： 后序遍历，又叫后根遍历。 遍历顺序：左子树 - 右子树 - 根 代码 ： 除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍

    2024年02月09日
    浏览(42)
  • 【数据结构 —— 二叉树的链式结构实现】

    【数据结构 —— 二叉树的链式结构实现】

    树是一种非线性的数据结构，它是由n（n=0）个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 1.有一个 特殊的结点，称为根结点 ，根节点没有前驱结点 2.除根节点外， 其余结点被分成M(M0)个互不相交

    2024年02月05日
    浏览(54)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包