数据结构实验5：二叉树的应用

最新推荐文章于 2024-08-10 16:08:46 发布
最新推荐文章于 2024-08-10 16:08:46 发布
阅读量1.4k 收藏 22
点赞数 20
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58628068/article/details/135524719
版权

目录

一、实验目的

二、实验原理

1. 基本概念

2. 基本操作

2.1 二叉数的定义

2.2 二叉树的建立

2.2.1 创建新节点

2.2.2 建立二叉树

2.3 二叉树的遍历

2.3.1 先序遍历(NLR)

2.3.2 中序遍历(LNR)

2.3.3 后序遍历(LRN)

2.3.4 层次遍历

2.4 二叉树的节点个数统计

2.5 二叉树的深度计算

三、实验内容

问题描述

代码

截图

一、实验目的

1、掌握二叉树的定义；

2．掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计

算等。

二、实验原理

1. 基本概念

  1. 节点（Node）： 二叉树的基本单元是节点。每个节点包含一个数据元素和指向左子节点和右子节点的指针。

  2. 根节点（Root）： 树的顶部节点称为根节点。每个二叉树只有一个根节点。

  3. 叶节点（Leaf）： 没有子节点的节点称为叶节点，也叫终端节点。它们是树结构的末端。

  4. 父节点（Parent）和子节点（Child）： 一个节点的直接上级是其父节点，而直接下级是其子节点。每个节点最多有一个父节点，但可以有零个、一个或两个子节点。

  5. 子树（Subtree）： 由一个节点及其所有后代节点组成的树称为子树。

  6. 深度（Depth）： 一个节点的深度是指从根节点到该节点的路径的长度。根节点的深度为0。

  7. 高度（Height）： 一棵树的高度是指树中任意节点的最大深度。也就是说，树的高度是从根节点到最深叶节点的最长路径。

  8. 层次（Level）： 一棵树的层次是指树中的节点分布在哪一层。根节点在第一层，其子节点在第二层，以此类推。

  9. 二叉搜索树（Binary Search Tree，BST）： 是一种特殊的二叉树，其中每个节点的左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。

  10. 遍历（Traversal）： 访问二叉树中所有节点的一种方式。常见的遍历方式有前序遍历、中序遍历和后序遍历。

2. 基本操作

2.1 二叉数的定义

  1. 空二叉树（Empty Binary Tree）： 一个二叉树可以是空的，即不包含任何节点。

  2. 非空二叉树（Non-empty Binary Tree）： 一个非空二叉树包含一个根节点，以及分别为左子树和右子树的两个二叉树。

    • 根节点包含一个数据元素。
    • 左子树和右子树都是二叉树，可以是空二叉树或非空二叉树
struct TreeNode {
    int data;
    struct TreeNode* left;//左孩子
    struct TreeNode* right;//右孩子
};

2.2 二叉树的建立

2.2.1 创建新节点

分配内存，且左孩子和右孩子指针置为NULL

struct TreeNode* createNode(int elem) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    if (newNode == NULL) {//未分配成功
        cout << "内存分配错误" << endl;
        exit(EXIT_FAILURE);
    }
    newNode->data = elem;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;//返回新节点
}
2.2.2 建立二叉树

递归建立

struct TreeNode* buildTree() {
    int elem;
    cout << "输入节点的数值（-1代表空节点）:";
    cin >> elem;
    if (elem == -1) {//输入的是空节点
        return NULL;
    }
    struct TreeNode* root = createNode(elem);//创建新节点
    cout << "输入" << elem << "的左节点" << endl;
    root->left = buildTree();
    cout << "输入" << elem << "的右节点" << endl;
    root->right = buildTree();
    return root;
}

2.3 二叉树的遍历

2.3.1 先序遍历(NLR)

其遍历顺序为先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。

void preOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        cout << root->data << " ";//访问节点
        preOrderTraversal(root->left);//访问左孩子
        preOrderTraversal(root->right);//访问右孩子
    }
}
2.3.2 中序遍历(LNR)

其遍历顺序为先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。

void inOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        inOrderTraversal(root->left);//访问左孩子
        cout << root->data << " ";//访问节点
        inOrderTraversal(root->right);//访问右孩子
    }
}
2.3.3 后序遍历(LRN)

其遍历顺序为先递归后序遍历左子树，然后访问右子树，最后递归地后序遍历根节点。

void postOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        postOrderTraversal(root->left);//访问左孩子
        postOrderTraversal(root->right);//访问右孩子
        cout << root->data << " ";//访问节点
    }
}
2.3.4 层次遍历

层次遍历是一种按照树的层级顺序逐层访问节点的遍历方式，也称为广度优先遍历（Breadth-First Traversal）。这种遍历方法通常使用队列来实现，确保每一层的节点按顺序被访问。

  1. 初始化： 创建一个队列，并将根节点入队。

  2. 循环直到队列为空：

    • 从队列中取出一个节点，访问该节点。
    • 如果该节点有左子节点，将左子节点入队。
    • 如果该节点有右子节点，将右子节点入队。

  3. 重复步骤2，直到队列为空。

struct TreeNode {
    int data;
    struct TreeNode* left;//左孩子
    struct TreeNode* right;//右孩子
};

// 定义队列节点
typedef struct QueueNode {
    struct TreeNode* treeNode;//二叉树节点的指针
    struct QueueNode* next;//下一个节点的指针
} QueueNode;

// 定义队列
typedef struct Queue {
    QueueNode* front;//队列的前端
    QueueNode* rear;//队列的后端
} Queue;

// 初始化队列
void initializeQueue(Queue* queue) {
    queue->front = queue->rear = NULL;
}

// 入队
void enqueue(Queue* queue, TreeNode* treeNode) {
    //创建一个新的队列节点
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->treeNode = treeNode;
    newNode->next = NULL;

    if (queue->rear == NULL) {//如果队列为空，则此节点为第一个节点
        queue->front = queue->rear = newNode;
    }
    else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

// 出队
TreeNode* dequeue(Queue* queue) {
    if (queue->front == NULL) {
        return NULL; // 空队列
    }

    TreeNode* treeNode = queue->front->treeNode;
    QueueNode* temp = queue->front;

    queue->front = queue->front->next;
    free(temp);

    if (queue->front == NULL) {//如果是空队列
        queue->rear = NULL;
    }

    return treeNode;
}

// 层次遍历
void levelOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return; // 空树
    }

    Queue queue;
    initializeQueue(&queue);//初始化队列

    enqueue(&queue, root);//入队

    while (queue.front != NULL) {//当队列不为空
        TreeNode* current = dequeue(&queue);//当前出队的节点
        cout << current->data<<" ";

        if (current->left != NULL) {//若左子树不为空
            enqueue(&queue, current->left);
        }

        if (current->right != NULL) {//若右子树不为空
            enqueue(&queue, current->right);
        }
    }
}

2.4 二叉树的节点个数统计

采用递归的方式进行统计

int countNodes(TreeNode* root) {
    if (root == NULL) {//如果为空节点
        return 0;
    }
    else {
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
}

2.5 二叉树的深度计算

采用递归的方式进行计算

int calculateDepth(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    else {
        int leftDepth = calculateDepth(root->left);//左子树的深度
        int rightDepth = calculateDepth(root->right);//右子树的深度
        if (leftDepth > rightDepth) {//如果左子树更深
            return 1 + leftDepth;
        }
        else {
            return 1 + rightDepth;
        }
    }
}

三、实验内容

问题描述

1．以二叉链表表示二叉树，建立一棵二叉树（算法 5.3）；

2．输出二叉树的中序遍历结果（算法 5.1）；

3．输出二叉树的前序遍历结果（见讲稿）；

4．输出二叉树的后序遍历结果（见讲稿）；

5．计算二叉树的深度（算法 5.5）；

6．统计二叉树的结点个数（算法 5.6）；

7．统计二叉树的叶结点个数；

8．统计二叉树的度为 1 的结点个数；

9．输出二叉树中从每个叶子结点到根结点的路径。

代码

#include<iostream>
#include <vector>
using namespace std;

struct TreeNode {
    int data;
    struct TreeNode* left;//左孩子
    struct TreeNode* right;//右孩子
};

//建立节点
struct TreeNode* createNode(int elem) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    if (newNode == NULL) {//未分配成功
        cout << "内存分配错误" << endl;
        exit(EXIT_FAILURE);
    }
    newNode->data = elem;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;//返回新节点
}

//构建二叉树
struct TreeNode* buildTree() {
    int elem;
    cout << "输入节点的数值（-1代表空节点）:";
    cin >> elem;
    if (elem == -1) {//输入的是空节点
        return NULL;
    }
    struct TreeNode* root = createNode(elem);//创建新节点
    cout << "输入" << elem << "的左节点" << endl;
    root->left = buildTree();
    cout << "输入" << elem << "的右节点" << endl;
    root->right = buildTree();
    return root;
}

//NLR
void preOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        cout << root->data << " ";//访问节点
        preOrderTraversal(root->left);//访问左孩子
        preOrderTraversal(root->right);//访问右孩子
    }
}

//LNR
void inOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        inOrderTraversal(root->left);//访问左孩子
        cout << root->data << " ";//访问节点
        inOrderTraversal(root->right);//访问右孩子
    }
}

//LRN
void postOrderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        postOrderTraversal(root->left);//访问左孩子
        postOrderTraversal(root->right);//访问右孩子
        cout << root->data << " ";//访问节点
    }
}

//统计节点数
int countNodes(TreeNode* root) {
    if (root == NULL) {//如果为空节点
        return 0;
    }
    else {
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
}
//统计叶节点个数
//实质统计左右子树均为空的节点
int countLeafNodes(TreeNode* root) {
    if (root == NULL) {//如果为空节点
        return 0;
    }
    else {
        if (root->left == NULL && root->right == NULL) {
            return 1 + countLeafNodes(root->left) + countLeafNodes(root->right);
        }
        else {
            return countLeafNodes(root->left) + countLeafNodes(root->right);
        }
    }
}
//统计单节点个数
int countOneNodes(TreeNode* root) {
    if (root == NULL) {//如果为空节点
        return 0;
    }
    else {
        if (((root->left == NULL) && (root->right!=NULL))||((root->right == NULL) && (root->left != NULL)) ) {//如果是单节点
            return 1 + countOneNodes(root->left) + countOneNodes(root->right);
        }
        else {
            return countOneNodes(root->left) + countOneNodes(root->right);
        }
    }
}

//计算深度
int calculateDepth(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    else {
        int leftDepth = calculateDepth(root->left);//左子树的深度
        int rightDepth = calculateDepth(root->right);//右子树的深度
        if (leftDepth > rightDepth) {//如果左子树更深
            return 1 + leftDepth;
        }
        else {
            return 1 + rightDepth;
        }
    }
}

// 构建二叉树，并输出从叶子节点到根节点的路径
void buildTreeAndPrintPaths(TreeNode* root, vector<int>& path) {
    if (root == nullptr) {
        return;
    }

    // 将当前节点加入路径
    path.push_back(root->data);

    // 如果是叶子节点，打印路径
    if (root->left == nullptr && root->right == nullptr) {
        cout << "Path from leaf to root: ";
        for (int i = path.size() - 1; i >= 0; --i) {
            cout << path[i] << " ";
        }
        cout << endl;
    }

    // 递归处理左子树和右子树
    buildTreeAndPrintPaths(root->left, path);
    buildTreeAndPrintPaths(root->right, path);

    // 在返回之前，将当前节点从路径中移除
    path.pop_back();
}

int main() {
    struct TreeNode* root=buildTree();//建立二叉树
    cout << endl <<"中序遍历的结果为：";
    inOrderTraversal(root);
    cout << endl << "先序遍历的结果为：";
    preOrderTraversal(root);
    cout << endl << "后序遍历的结果为：";
    postOrderTraversal(root);
    cout << endl << "二叉树的深度为：" << calculateDepth(root);
    cout << endl << "二叉树的节点个数为：" << countNodes(root);
    cout << endl << "二叉树的叶子节点个数为：" << countLeafNodes(root);
    cout << endl << "二叉树中度为1的节点个数为：" << countOneNodes(root);
    vector<int> path; // 用于存储路径的数组
    // 调用函数进行构建并输出路径
    buildTreeAndPrintPaths(root, path);
    return 0;
}

截图

 

数据结构之二叉树实验
// 在校菜鸟大学生的日常学习博客
09-01 4725
二叉树实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过实验掌握二叉树的基本存储结构； 掌握二叉树的建立与遍历的基本算法，并加以应用； 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握二叉树的链式存储结构—二叉链表的定义、构造、遍历等基本操作； 实验内容 完成二叉树的二叉链表的存储结构的定义、创建、前序遍历、中序遍历、后序遍历、求叶子数和求深度等函数的编写。完成以下函数的编写： (1) 编写一个函数输出结点的值。visit( BiTree T) (2)编写一个函
数据结构实验报告——二叉树
11-14
数据结构实验报告，二叉树实验报告。采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作
【数据结构】实验：二叉树的操作和应用（1）
最新发布
m0_73970214的博客
08-10 540
通过此次实验我掌握二叉树的非线性和递归特点：二叉树是一种非线性的数据结构，它不满足线性关系。在二叉树中，每个节点最多有两个子节点，分别是左子节点和右子节点。二叉树的遍历和操作可以通过递归来实现。前序遍历、中序遍历和后序遍历都是通过递归实现的。
数据结构实验（二叉树）
07-10
数据结构实验，二叉树类型的实现，完美代码、报告。
《数据结构》实验报告五：二叉树
热门推荐
Amentos的博客
10-30 1万+
《数据结构》实验报告：二叉树基本概念 + 结点总数 + 叶子结点数 + 二叉树深度 + 中序非递归遍历 算法实现
数据结构二叉树实验报告
01-04
数据结构二叉树实验报告
二叉树实验 （数据结构）
Popcorn_zyh的博客
11-03 1627
二叉树的遍历 数据结构 实验报告
1120-2019-数据结构-二叉树+线索二叉树
weixin_43221993的博客
11-20 176
ArrayList底层其实也是扩容。 数组：检索读取的效率还可以，但是插入删除的效率偏低。 链表：插入删除的效率好。但是检索读取的效率偏低。 所以引入二叉树。特别是二叉排序树、红黑树（HashMap的底层实现）。 对数据的增删改查的速度都会提高。 小概念 结点 根节点 父节点 子节点 叶子结点 结点的权（节点的值） 层 满二叉树 完全二叉树 一般来说我们只说二叉树。 前序遍历 中序遍历 后序遍历 ...
数据结构实验2.2：二叉树遍历的一些应用.doc
10-29
在本实验报告中，我们探讨了数据结构中的一个重要概念——二叉树及其遍历方法的应用。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树在计算机科学中有着广泛的应用...
天津理工大学中加专业数据结构实验二：二叉树的操作
06-07
定义二叉树结点的数据结构如下： ```c typedef struct BiTreeNode { char data; struct BiTreeNode *left; struct BiTreeNode *right; } BiTreeNode, *BiTree; ``` 其中，`data`用于存储结点数据，`left`和`...
数据机构实验报告：二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造实验报告.doc
12-18
二叉树是数据结构中的一种重要类型，它以分层结构表示数据，广泛应用于计算机科学的多个领域，如编译器设计、数据库管理等。 二叉排序树（BST），也称为二叉查找树，是一种特殊的二叉树，其每个节点的左子树中的...
数据结构二叉树的实验报告
10-27
本程序可以在98/2000/XP下运行,可以用VC++6.0执行 熟练掌握各种遍历策略的递归和非递归算法；灵活运用遍历算法实现二叉树其他操作。
二叉树实验报告
06-24
二叉树的实验报告，内有完整的二叉树实验的代码，用C++实现的
数据结构试验3-二叉树实验报告含源码
03-08
数据结构实验报告，二叉树。需要的请放心下载！
《数据结构》实验二叉树
12-18
编写一个程序，实现二叉树的各种运算，并在此基础上设计一个主程序完成输入二叉树；输出特定结点的左、右孩子结点值；输出二叉树的深度；输出二叉树的宽度；输出二叉树的结点个数；输出二叉树的叶子结点个数等功能。
数据结构实验 二叉树
10-23
这是个比较典型的二叉树的数据结构实验，有建树等等操作，是数据结构的重要知识点。。。
数据结构实验：二叉树的基本操作
12-04
南邮数据结构实验使用C++描述，二叉树的基本操作
数据结构实验报告：二叉树的基本操作及应用
2码8改
01-30 1万+
二叉树的基本操作实现&&果子合并 一、实验目的 1、使学生熟练掌握二叉树的逻辑结构和存储结构。 2、熟练掌握二叉树的各种遍历算法。 3、使学生熟练掌握哈夫曼树的生成算法。 4、熟练掌握哈夫曼编码的方法。 二、实验内容 本次实验提供4个题目，难度不等，学生可以根据自己的情况选做，其中题目一是必做题，其它选作！ 题目一：二叉...
【数据结构】实验九：二叉树
m0_65787507的博客
07-27 1199
数据结构实验
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值