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

已于 2023-09-12 11:42:23 修改
阅读量359 收藏 2
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 算法 c++ stl
于 2023-09-11 18:38:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ikun66666/article/details/132815031
版权

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

二叉树的存储结构

typedef int BTDataType;
// 二叉树的结构
typedef struct BinaryTreeNode {
    BTDataType data;             // 树的值
    struct BinaryTreeNode *left; // 左孩子
    struct BinaryTreeNode *right;// 右孩子
} BinaryTreeNode;

二叉树的深度优先遍历

在这里插入图片描述

前序遍历

前序遍历，又叫先根遍历。
遍历顺序：根 -> 左子树 -> 右子树

代码：

// 前序遍历
void BinaryTreePrevOrder(BinaryTreeNode *root) {
    // 前序遍历 根、左子树、右子树
    // 如果root为空，递归结束
    if (root == NULL) {
        printf("NULL ");
        return;
    }

    printf("%d ", root->data);
    BinaryTreePrevOrder(root->left);
    BinaryTreePrevOrder(root->right);
}

中序遍历

中序遍历，又叫中根遍历。
遍历顺序：左子树 -> 根 -> 右子树

代码：

// 中序遍历
void BinaryTreeInOrder(BinaryTreeNode *root) {
    // 中序遍历 - 左子树、根、右子树
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    BinaryTreeInOrder(root->left);
    printf("%d ", root->data);
    BinaryTreeInOrder(root->right);
}

后序遍历

后序遍历，又叫后根遍历。
遍历顺序：左子树 -> 右子树 -> 根

代码：

// 后序遍历
void BinaryPostOrder(BinaryTreeNode *root) {
    // 后序遍历 - 左子树、右子树、根
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    BinaryPostOrder(root->left);
    BinaryPostOrder(root->right);
    printf("%d ", root->data);
}

二叉树的广度优先遍历

层序遍历

除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

在这里插入图片描述

思路（借助一个队列）：

  1. 先把根入队列，然后开始从队头出数据。
  2. 出队头的数据，把它的左孩子和右孩子依次从队尾入队列（NULL不入队列）。
  3. 重复进行步骤2，直到队列为空为止。

img

特点：借助队列先进先出的性质，上一层数据出队列的时候带入下一层数据。

// 层序遍历 - 利用队列
void BinaryTreeLevelOrder(BinaryTreeNode *root) {
    // 创建一个队列，队列中入数据，取队头，然后带左右子树，出一个数，带一个树的所有子树
    Queue q;
    QueueInit(&q);
    if (root) {
        // root不为NULL，就入队列
        QueuePush(&q, root);
    }

    while (!QueueEmpty(&q)) {
        // 取队头，打印
        BinaryTreeNode *front = QueueFront(&q);
        printf("%d ", front->data);

        // 取完POP
        QueuePop(&q);
        // 取队头，带下一层,
        if (front->left) {
            QueuePush(&q, front->left);
        }

        if (front->right) {
            QueuePush(&q, front->right);
        }
    }
    printf("\n");
    QueueDestroy(&q);
}

二叉树的节点个数

求解树的节点总数时，可以将问题拆解成子问题：

  1. 若为空，则结点个数为0。
  2. 若不为空，则结点个数 = 左子树节点个数 + 右子树节点个数 + 1（自己）。

代码：

// 求二叉树节点个数
int BinaryTreeSize(BinaryTreeNode *root) {
    if (root == NULL) {
        return 0;
    }
    return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}

二叉树的叶子节点个数

子问题拆解：

  1. 若为空，则叶子结点个数为0。
  2. 若结点的左指针和右指针均为空，则叶子结点个数为1。
  3. 除上述两种情况外，说明该树存在子树，其叶子结点个数 = 左子树的叶子结点个数 + 右子树的叶子结点个数。

代码：

// 求二叉树的叶子节点个数
int BinaryTreeLeafSize(BinaryTreeNode *root) {
    if (root == NULL) {
        return 0;
    }

    if (root->left == NULL && root->right == NULL) {
        return 1;
    }

    return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

第K层节点的个数

思路：
相对于根结点的第k层结点的个数 = 相对于以其左孩子为根的第k-1层结点的个数 + 相对于以其右孩子为根的第k-1层结点的个数。

在这里插入图片描述

代码：

// 求第k层的节点个数 k>=1
int BinaryTreeLevelSize(BinaryTreeNode *root, int k) {
    if (root == NULL) {
        return 0;
    }

    if (k == 1) {
        return 1;
    }

    return BinaryTreeLevelSize(root->left, k - 1) + BinaryTreeLevelSize(root->right, k - 1);
}

值为x的节点

子问题：

  1. 先判断根结点是否是目标结点。
  2. 再去左子树中寻找。
  3. 最后去右子树中寻找。

代码：

// 二叉树查找值为x的节点
BinaryTreeNode *BinaryTreeFind(BinaryTreeNode *root, BTDataType x) {
    if (root == NULL) {
        return NULL;
    }

    if (root->data == x) {
        return root;
    }

    // 左子树递归的节点保存到leftTree中,如果leftTree不为NULL，则return leftTree
    BinaryTreeNode *leftTree = BinaryTreeFind(root->left, x);
    if (leftTree) {
        return leftTree;
    }

    // 右子树递归的节点保存到rightTree中,如果rightTree不为NULL，则return rightTree
    BinaryTreeNode *rightTree = BinaryTreeFind(root->right, x);
    if (rightTree) {
        return rightTree;
    }

    // 找不到，返回NULL
    return NULL;
}

树的高度

子问题：

  1. 若为空，则深度为0。
  2. 若不为空，则树的最大深度 = 左右子树中深度较大的值 + 1。

代码：

// 求二叉树的高度
int BinaryTreeHeight(BinaryTreeNode *root) {
    // 求左子树的高度，右子树的高度
    // 取最大的
    if (root == NULL) {
        return 0;
    }
    int leftHeight = BinaryTreeHeight(root->left);
    int rightHeight = BinaryTreeHeight(root->right);
	
	//如果左右子树两边相等就取左边的高度,所以大于等于
    return leftHeight >= rightHeight ? leftHeight + 1 : rightHeight + 1;
}

判断二叉树是否是完全二叉树

判断二叉树是否是完全二叉树的方法与二叉树的层序遍历类似，但又有一些不同。

思路（借助一个队列）：

  1. 先把根入队列，然后开始从队头出数据。
  2. 出队头的数据，把它的左孩子和右孩子依次从队尾入队列（NULL也入队列）。
  3. 重复进行步骤2，直到读取到的队头数据为NULL时停止入队列。
  4. 检查队列中剩余数据，若全为NULL，则是完全二叉树；若其中有一个非空的数据，则不是完全二叉树。

在这里插入图片描述

代码：

// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BinaryTreeNode *root) {
    // 层序走，走到第一个为空的时候，就跳出去，如果是满二叉树，后面的节点都应该为空
    Queue q;
    QueueInit(&q);
    if (root) {
        QueuePush(&q, root);
    }

    while (!QueueEmpty(&q)) {
        BinaryTreeNode *front = QueueFront(&q);
        QueuePop(&q);

        if (front == NULL) {
            break;
        } else {
            QueuePush(&q, front->left);
            QueuePush(&q, front->right);
        }
    }
    // 出到空以后，如果后面全是空，则是完全二叉树
    while (!QueueEmpty(&q)) {
        BinaryTreeNode *front = QueueFront(&q);
        QueuePop(&q);
        if (front != NULL) {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

判断二叉树是否是单值二叉树

单值二叉树，所有节点的值都相同的二叉树即为单值二叉树，判断某一棵二叉树是否是单值二叉树的一般步骤如下：

  1. 判断根的左孩子的值与根结点是否相同。
  2. 判断根的右孩子的值与根结点是否相同。
  3. 判断以根的左孩子为根的二叉树是否是单值二叉树。
  4. 判断以根的右孩子为根的二叉树是否是单值二叉树。

若满足以上情况，则是单值二叉树。

注：空树也是单值二叉树。

代码：

//求单值二叉树
bool isUnivalTree(BinaryTreeNode *root) {
    if (root == nullptr) {
        return true;
    }

    if (root->left && root->data != root->left->data) {
        return false;
    }
    
	if (root->right && root->data != root->right->data) {
        return false;
    }

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

判断二叉树是否是对称二叉树

对称二叉树，这里所说的对称是指镜像对称：

要判断某二叉树是否是对称二叉树，则判断其根结点的左子树和右子树是否是镜像对称即可。因为是镜像对称，所以左子树的遍历方式和右子树的遍历方式是不同的，准确来说，左子树和右子树的遍历是反方向进行的。

代码：

//求对称二叉树
bool _isSymmetric(BinaryTreeNode *left, BinaryTreeNode *right) {
    // 两个都为NULL，对称
    if (left == NULL && right == NULL)
        return true;

    // 两个其中一个为NULL，一个不为NULL，不对称
    if (left == NULL || right == NULL)
        return false;

    // left的左孩子的值和right的值不相等，不对称
    if (left->data != right->data)
        return false;

    // 左子树的左孩子，和右子树的右孩子对比，然后左子树的右孩子和右子树的左孩子在对比
    return _isSymmetric(left->left, right->right) && _isSymmetric(left->right, right->left);
}

bool isSymmetric(BinaryTreeNode *root) {
    if (root == nullptr) {
        return true;
    }

    return _isSymmetric(root->left, root->right);
}

翻转二叉树

思路：

  1. 翻转左子树。
  2. 翻转右子树。
  3. 交换左右子树的位置。

代码：

BinaryTreeNode *invertTree(BinaryTreeNode *root) {
    if (root == nullptr) {
        return nullptr;
    }

    BinaryTreeNode *leftTree = invertTree(root->left);
    BinaryTreeNode *rightTree = invertTree(root->right);

    root->left = rightTree;
    root->right = leftTree;

    return root;
}

二叉树的构建和销毁

// 申请树节点
BinaryTreeNode *BuyBinaryTreeNode(BTDataType x) {
    BinaryTreeNode *newnode = (BinaryTreeNode *) malloc(sizeof(BinaryTreeNode));
    if (newnode == NULL) {
        perror("malloc fail");
        exit(-1);
    }
    newnode->data = x;
    newnode->left = newnode->right = NULL;
    return newnode;
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BinaryTreeNode *BinaryTreeCreate(BTDataType *a, int *pi) {
    if (a[*pi] == '#') {
        (*pi)++;
        return NULL;
    }

    BinaryTreeNode *root = (BinaryTreeNode *) malloc(sizeof(BinaryTreeNode));
    if (root == NULL) {
        perror("malloc fail");
        exit(-1);
    }
    root->data = a[(*pi)++];

    root->left = BinaryTreeCreate(a, pi);
    root->right = BinaryTreeCreate(a, pi);
    return root;
}

销毁：

// 二叉树销毁
void BinaryTreeDestory(BinaryTreeNode **root) {
    if (*root == NULL) {
        return;
    }
    // 后序遍历销毁，根要最后释放
    BinaryTreeDestory(&(*root)->left);
    BinaryTreeDestory(&(*root)->right);
    free(*root);
    *root = NULL;
}
ikun66666
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构-二叉树的链式存储
qq_45967533的博客
03-20 1万+
文章目录二叉树的链式结构链式结构的遍历二叉树链式存储的实现二叉树节点的创建前序遍历中序遍历后序遍历二叉树元素个数叶节点的个数第k层节点的个数查找元素二叉树销毁二叉树的层序遍历判断是否为完全二叉树 二叉树的链式结构 二叉树的存储结构有顺序结构和链式结构两种，顺序结构我已经在上篇进行了详细的讲解，地址：数据结构-二叉树的顺序存储与堆（堆排序），本篇我们就主要讲解二叉树的链式存储。 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右
链式二叉树的代码实现
weixin_69283129的博客
09-25 1154
C语言版链式二叉树的代码实现
【数据结构】二叉树——链式结构的实现（代码演示）
weixin_53269843的博客
05-29 2224
主要内容包括：二叉树的创建、二叉树的销毁、二叉树的遍历（前序、中序、后续、层序）、 二叉树的节点个数、二叉树的叶子节点个数、二叉树的深度、以及代码演示
数据结构：二叉树的链式结构及代码实现
最新发布
cbwjty的博客
07-07 779
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。注意：上面的代码不是真正创建二叉树的代码 ，真正的创建二叉树的代码在后面重点讲解。再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：：根结点，根结点的左子树、根结点的右子树组成的。
[数据结构]二叉树的链式存储结构
qq_66767938的博客
03-23 3085
二叉树的链式存储结构
二叉树——链式结构的代码实现（包含前中后遍历的实现）
m0_57249790的博客
04-30 2002
目录 二叉树的创建 构建一颗二叉树 二叉树的销毁 创建一个新结点 计算二叉树的结点个数 计算二叉树的叶子结点个数 计算二叉树第k层节点的个数 二叉树查找值为x的节点 二叉树前序遍历 二叉树中序遍历 二叉树的后序遍历 二叉树的层序遍历 判断二叉树是否是完全二叉树 二叉树的创建 根据二叉树的结构，我们用链表来链接每个结点的左右孩子，并且给每个结点定义一个数值。 如图所示： 代码如下： typedef char BTDataType;//老样子 便于控制数据类型 ..
C语言实现二叉树链式存储
xianyu4625的博客
04-19 3296
C语言递归实现二叉树的存储，构建二叉树，遍历二叉树，测叶子结点和树高度，删除树
数据结构 二叉树 链式
06-01
总的来说，这个资源提供了深入理解二叉树链式表示和遍历方法的实践机会。通过分析代码、阅读实验报告并运行示例程序，学习者可以强化数据结构的知识，提高编程技能，这对于任何IT专业人士来说都是非常宝贵的经验。
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
数据结构：二叉树（链式存储）
12-07
以上就是关于“数据结构：二叉树（链式存储）”的主要内容，包括了二叉树的链式存储结构，递归创建二叉树的方法，以及三种遍历策略的实现。这些知识对于理解和操作二叉树至关重要，也是数据结构和算法学习中的基础...
C语言 数据结构 二叉树的链式存储 基本操作（附输入样例和讲解）
qq_31744851的博客
08-30 3409
代码参照了严蔚敏、吴伟民编写的数据结构（C语言版）。 部分内容参考了这位大佬： https://www.cnblogs.com/cpoint/p/3479788.html 所有代码采用C语言编写。讲解请查看注释。 头文件及宏定义 #include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h> //#include"链队列.h"//层次遍历时用到 #define OK 1 #
链式结构存储二叉树的基本操作
09-01
采用链式结构存放二叉树，实现二叉数的创建，实现二叉数的遍历（前序，后序，中序层次遍历），分别求二叉树的叶子结点和结点的数目，二叉树的查找，二叉树的深度。
二叉树（C语言实现）——链式存储结构
Mr_John
10-30 3494
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define QueueSize 200 typedef char DataType; typedef struct TNode { DataType data; struct TNode* lchild; struct TNode* rchild; }BiTree; BiTree* Creat_Tree(); // 创建树 Dat.
【C++实现二叉树的链式存储】
qq_63184211的博客
02-04 830
二叉树链式存储实现以及相关常用操作。
二叉树链式存储和先序，中序，后序，层次遍历代码实现和讲解
m0_75220252的博客
06-20 699
二叉树链式存储和先序，中序，后序，层次遍历代码实现和讲解
二叉树的链式结构 - C语言（含有大量递归）
Yawesh的博客
06-04 1706
二叉树的链式结构 - C语言
二叉树的链式存储代码实现
做一个快乐学习者
04-30 2166
使用三个指针域，分别是父节点指针，左孩子节点指针，右孩子节点指针，便于找到节点的父亲。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define COUNT 100 #pragma warning(disable:4996) /* 二叉树的链式结构存储实现 */ //二叉树结...
使用C语言实现二叉树的链式存储
Keep_Trying_Go的博客
08-18 3117
使用C语言实现二叉树的链式存储
二叉树的先序，中序，后序遍历的实现
qq_43811879的博客
11-29 971
先序遍历 若二叉树为空，则空操作；否则 1.访问根节点 2.先序遍历左子树 3.先序遍历右子树 中序遍历 若二叉树为空，则空操作；否则 1.中序遍历左子树 2.访问根节点 3.中序遍历右子树 后序遍历 若二叉树为空，则空操作；否则 1.后续遍历左子树 2.后续遍历右子树 3.访问根节点 用递归的方式实现二叉树的遍历： #include <bits/stdc++.h> using namespace std; typedef char TElemType; typedef int Status;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值