数据结构之树的一些基本操作

最新推荐文章于 2022-08-27 13:31:49 发布
最新推荐文章于 2022-08-27 13:31:49 发布
阅读量2.1k 收藏 21
点赞数 3
分类专栏： 苏嵌学习 文章标签： 结构 struct 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/believe_s/article/details/76563261
版权

树是由根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。
头文件 tree.h

#ifndef __TREE_H__
#define __TREE_H__

#include "error.h"

struct _treeNode;                   // 结构体声明

// 孩子结点链表的类型
typedef struct _childNode
{
    struct _treeNode * childNode;
    struct _childNode* next;        // 指向孩子结点链表下一个元素
}ChildNode;

// 树节点类型
typedef char TreeData;
typedef struct _treeNode
{
    TreeData data;
    struct _treeNode * parent;      // 指向父节点的指针
    struct _treeNode * next;        // 指向链表的下一个结点
    struct _childNode* childList;   // 孩子链表的头节点
    int degree;                     // 结点的度
}TreeNode;

typedef struct _tree
{
    struct _treeNode* head;         // 树链表的头节点
    int len;                        // 树结点个数
}Tree;

// 定义一个函数指针类型
typedef void(*TreePrint)(TreeNode *node);

Tree* Create_Tree();

// pos 代表要插入结点父亲结点的位置
// 约定：
// 1 新插入的结点插入在当前父亲结点所有孩子的右边
// 2 根节点的位置是 0
int Insert_Tree (Tree* tree, TreeData data, int pos);

// 打印树
void Display (Tree* tree, TreePrint pFunc);

// 删除结点
int Delete (Tree* tree, int pos, TreeData *x);

// 求指定位置树结点的值
int Tree_Get (Tree* tree, int pos, TreeData *x);

// 清空树中所有的节点
int Tree_Clear (Tree* tree);

// 树的销毁 
void Tree_Destroy   (Tree* tree);

// 获取根节点的地址
TreeNode* Tree_Root (Tree* tree);

// 求树的结点个数
int Tree_Count  (Tree* tree);

// 求树的高度
int Tree_Height (Tree* tree);

// 求树的度
int Tree_Degree (Tree* tree);

// 打印
void printA (TreeNode* node);

#endif  // __TREE_H__

源文件 tree.c

#include "tree.h"
#include <stdlib.h>

Tree *Create_Tree()
{
    // 创建树节点
    Tree* tree = (Tree*) malloc(sizeof(Tree)/sizeof(char));
    if (NULL == tree)
    {
        errno = MALLOC_ERROR;
        return NULL;
    }

    // 给树结点链表创建头节点
    tree->head = (TreeNode*) malloc(sizeof(TreeNode)/sizeof(char));
    if (NULL == tree->head)
    {
        errno = MALLOC_ERROR;
        free (tree);
        return NULL;
    }

    tree->head->parent    = NULL;
    tree->head->childList = NULL;
    tree->head->next      = NULL;   // 代表树中没有结点

    // 空树结点为0
    tree->len = 0;

    return tree;
}

int Insert_Tree (Tree* tree, TreeData data, int pos)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (pos != 0 && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    // 新建结点
    TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode)/sizeof(char));
    if (NULL == node)
    {   
        errno = MALLOC_ERROR;
        return FALSE;
    }

    node->data = data;
    node->next = NULL;

    // 创建该新节点的孩子结点链表的头节点
    node->childList = (ChildNode*) malloc(sizeof(ChildNode)/sizeof(char));
    if (NULL == node->childList)
    {   
        errno = MALLOC_ERROR;
        free (node);
        return FALSE;
    }   
    node->childList->next      = NULL;
    node->childList->childNode = NULL;

    node->degree = 0;

    int i;
    // 找父节点
    TreeNode* parent = tree->head->next;     // 当前树节点的第一个结点
    for (i = 0; i < pos; i++)
    {
        parent = parent->next;
    }
    node->parent = parent; 

    // 在父亲结点的子结点链表中加入一个结点
    if (parent != NULL)
    {
        // 创建一个孩子结点
        ChildNode* childnode = (ChildNode*) malloc(sizeof(ChildNode)/sizeof(char));
        if (NULL == childnode)
        {
            errno = MALLOC_ERROR;
            free (node->childList);
            free (node);
            return FALSE;
        }
        childnode->childNode = node;
        childnode->next      = NULL;

        // 加入到父亲结点子结点链表当中
        ChildNode* tmp = parent->childList;   // 子结点链表的头节点
        while (tmp->next)
        {   
            tmp = tmp->next;
        }
        tmp->next = childnode;
        parent->degree += 1;
    }

    TreeNode* tmp = tree->head;              // 树节点链表的头节点
    while (tmp->next)
    {
        tmp = tmp->next;
    }
    tmp->next = node;
    tree->len += 1;

    return TRUE;
}

// 递归打印结点
void r_display (TreeNode* node, int gap, TreePrint pFunc)
{
    if (NULL == node)
    {
        return;
    }

    // 打印距离前一个结点的距离
    int i;
    for (i = 0; i < gap; i++)
    {
        printf ("%c", '-');
    }

    // 打印结点自己
    // printf ("%c\n", node->data);
    pFunc (node);

    ChildNode* child = node->childList->next; // 该结点的第一个孩子
    // 打印该结点的孩子
    while (child)
    {
        r_display (child->childNode, gap+4, pFunc);
        child = child->next;  // 下一个孩子
    }
}

void Display (Tree *tree, TreePrint pFunc)
{
    if (NULL == tree)
    {
        return;
    }

    r_display (tree->head->next, 0, pFunc);
}

void r_delete (Tree *tree, TreeNode *node)
{
    if (NULL == tree || NULL == node)
        return;

    // 从树链表中移除这个结点,找node的前一个结点
    TreeNode* tmp = tree->head;  // 链表的头节点
    while (tmp->next)
    {
        if (tmp->next == node)
        {
            tmp->next = node->next;
            tree->len--;
            break;
        }
        tmp = tmp->next;
    }

    // 将父亲结点中子结点链表中指向node的结点删除
    TreeNode* parent = node->parent;
    if (NULL != parent)
    {
        ChildNode* tmp = parent->childList;  // 子结点链表的头节点
        while (tmp->next)
        {
            if (tmp->next->childNode == node)
            {
                ChildNode* p = tmp->next;
                tmp->next    = p->next;
                free (p);
                parent->degree--;
                break;
            }
            tmp = tmp->next;
        }
    }

    // 将该结点的孩子结点删掉
    ChildNode* child = node->childList->next; 
    // 子结点链表中的第一个结点
    while (child)
    {
        ChildNode* pchild = child->next;
        r_delete (tree, child->childNode);
        child  = pchild;
    }

    free (node->childList);
    free (node);
}

int Delete (Tree *tree, int pos, TreeData *x)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (0 != pos && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    int i;
    // 找结点
    TreeNode* current = tree->head->next;  
    for (i = 0; i < pos; i++)
    {
        current = current->next;
    }

    *x = current->data;

    r_delete (tree, current);

    return TRUE;

}

int Tree_Get (Tree* tree, int pos, TreeData *x)
{
    if (NULL == tree || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (0 != pos && tree->len == pos)
    {
        errno = ERROR;
        return FALSE;
    }

    int i;
    // 找结点
    TreeNode* current = tree->head->next;  
    for (i = 0; i < pos; i++)
    {
        current = current->next;
    }

    *x = current->data;

    return TRUE;
}

int Tree_Clear (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    TreeData x;
    return Delete (tree, 0, &x);
}

void Tree_Destroy (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return;
    }

    Tree_Clear (tree);

    free (tree->head);
    free (tree);
}

TreeNode* Tree_Root (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return NULL;
    }

    return tree->head->next;
}

int Tree_Count (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    return tree->len;
}

// 递归求高度
int r_height (TreeNode* node)
{
    if (NULL == node)
    {
        return 0;
    }

    int subHeight = 0;
    int max       = 0;
    ChildNode* child = node->childList->next;
    while (child)
    {
        subHeight = r_height (child->childNode);
        if (subHeight > max)
        {
            max = subHeight;
        }
        child = child->next;
    }

    return max + 1;
}

int Tree_Height (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    int height = r_height (tree->head->next);

    return height;
}

// 递归求度
int r_degree (TreeNode* node)
{
    if (NULL == node)
    {
        return 0;
    }

    int max       = node->degree;
    int subDegree = 0;
    ChildNode* child = node->childList->next;
    while (child)
    {
        subDegree = r_degree (child->childNode);
        if (subDegree > max)
        {
            max = subDegree;
        }
        child = child->next;
    }

    return max;
}

int Tree_Degree (Tree* tree)
{
    if (NULL == tree)
    {
        errno = ERROR;
        return FALSE;
    }

    int degree = r_degree (tree->head->next);

    return degree;
}

void printA (TreeNode* node)
{
    printf ("%c\n", node->data);
}

主函数 main.c

#include <stdio.h>
#include "tree.h"



int main()
{
    Tree* tree = Create_Tree();
    if (NULL == tree)
    {
        myError ("Create_Tree");
        return -1;
    }

    Insert_Tree (tree, 'A', 0);
    Insert_Tree (tree, 'B', 0);
    Insert_Tree (tree, 'C', 0);
    Insert_Tree (tree, 'D', 0);
    Insert_Tree (tree, 'E', 1);
    Insert_Tree (tree, 'F', 1);
    Insert_Tree (tree, 'H', 3);
    Insert_Tree (tree, 'I', 3);
    Insert_Tree (tree, 'J', 3);
    Insert_Tree (tree, 'X', 3);
    Insert_Tree (tree, 'Z', 8);

    Display (tree, printA);

    //printf ("删除B ：\n");
    TreeData x;
    //Delete(tree, 1, &x);
    //Display(tree, printA);

    printf ("height = %d\n", Tree_Height(tree));
    printf ("degree = %d\n", Tree_Degree(tree));
    return 0;
}

error.h是我自己写的一个包含常见错误的头文件，这里我就不发了。

believe_s
关注
专栏目录
数据结构之一般树的基本操作
MRfly_的博客
01-03 1250
# include # include # include # include # include # include #define N 30 #define MAX 100 struct Birthdate { int year; int month; int day; }; struct data { struct Birthdate
数据结构树的基本操作_数据结构之二叉树的基本操作
weixin_31105189的博客
02-12 357
#include#include#include#define MaxSize 100typedefcharElemType;typedefstructnode{ElemType data;//数据类型struct node *lchild;//指向左孩子struct node *rchild;//指向右孩子}BTNode;void CreateBTNode(BTNode *&b,char...
数据结构实验-二叉树的基本操作
10-26
一、问题描述 运用二叉链表实现二叉树的基本操作，包括：创建二叉树的存储结构、复制已有的二叉树、计算已有的二叉树的深度、先根序序列、中根序序列、后根序序列等。 输入格式：AB#C##D## 二、实验目的 掌握二叉链表及二叉树的基本操作。 三、实验内容及要求 1、构造二叉树的二叉链表数据结构。 2、实现二叉树的创建、复制、计算二叉树的深度、先根序序列、中根序序列、后根序序列等操作。
数据结构树的基本操作_树的各类基本操作（数据结构）
weixin_42449339的博客
02-12 625
#include "iostream"/*输入：ABC DE G FABC DE G F*/#include "bits/stdc++.h"using namespace std;typedef struct bitnode{char data;bitnode *lchild,*rchild;} *bintree;bintree creatree(bintree &root)//先...
LeetCode206-反转链表
viva_la__vida的博客
09-26 103
LeetCode206-反转链表 题目 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 解法 方法一：递归 若输入的头节点是null就返回null 若输入的头节点的下一个节点是null，就返回当前头节点 将head.next节点及其之后的节点递归反转完成。设立一个cur节点，用来指向已经反转完成的这段链表的头节点。于此同时h
数据结构树的基本操作_数据结构-树的基本操作
weixin_42132352的博客
01-17 941
#include#include#includeusing namespace std;//ADTtypedef struct BiTNode{char data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;//建树void build(BiTree &T){char ch;cin>>ch;if(ch == '.') T ...
数据结构树的基本操作_数据结构二叉树的基本操作~~~~
weixin_42310347的博客
01-17 262
展开全部用递归的636f70793231313335323631343130323136353331333330356335方法实现以下算法：1．以二叉链表表示二叉树，建立一棵二叉树；2．输出二叉树的前序遍历结果；3．输出二叉树的中序遍历结果；4．输出二叉树的后序遍历结果；5．统计二叉树的叶结点个数；6．统计二叉树的结点个数；7．计算二叉树的深度。8．交换二叉树每个结点的左孩子和右孩子；#incl...
数据结构——二叉树的基本操作（C语言，完整优美实现）
明宇逸风的博客
10-28 9566
串 文章目录串前言一、树是什么？二、该如何理解树？三、各类树的存在形式四、二叉树的遍历方式深度遍历先序遍历中序遍历后序遍历层次遍历五、二叉树的实现1.二叉树的实现1.1 引入库以及设置结构体1.2初始化二叉树1.3队列的基本操作实现1.4二叉树深度遍历的三种方法1.5层次遍历1.6求子叶个数以及结点个数1.7串的输出功能1.8主函数实现上述全部功能2.运行截图总结 前言 1.本文就介绍了数据结构中二叉树的五条性质以及二叉树的存储结构 2.二叉树的基本操作的编程实现，掌握二叉树的建立、先序，中序，后序遍
数据结构之树
热门推荐
lishinho的博客
11-20 5万+
本篇只涉及树的概念范围和应考思路，不涉及具体结构或算法的实现与思考 1.树 在计算器科学中，树（英语：tree）是一种抽象数据类型或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： ①每个节点有零个或多个子节...
【数据结构】二叉树的基本操作
Jesonary的博客
08-27 3083
1、编写函数，创建一棵二叉树（递归算法和非递归算法）；2、编写函数，按树状结构输出二叉树；3、编写函数，用递归算法分别求二叉树的各种遍历序列；
操作系统之树的基本操作
05-08
操作系统之树的基本操作
数据结构实验-二叉排序树算法
10-26
根据给定的关键字序列，实现二叉排序树的基本操作。 输入格式：8, 10, 5, 6, 3, 13 二、实验目的 掌握二叉排序树的存储方法，实现二叉排序树的创建、查找、插入、删除、平均查找长度等基本操作。 三、实验内容及要求...
数据结构树的基本操作_数据结构树的基本操作(主要遍历）
weixin_30412847的博客
01-17 711
一． 实验目的将树的基本操作C语言实现，主要考察树的先序，中序，后序和层次遍历。二.主要内容本文所使用的二叉树如图：显然先序：ABCDEGF中序：CBEGDFA后序：CGEFDBA层次：ABCDEFGBiTree.h内容C++typedef char TElemType;typedef int Status;typedef struct BiTNode{TElemType data;struct ...
数据结构树基本操作
任萌新的小生活
09-18 939
本章内容：树的结构定义、递归的三种遍历、非递归的三种遍历、层次遍历、求深度、求特定结点以及测试的主函数。 #include <stdio.h> #include <stdlib.h> #define maxsize 50 //二叉树的链式存储 typedef struct BTNode { //树结点存储的类型可以更换，常用int、double、char等 ...
数据结构（五）树2：树的基本操作
___cc木槿
11-07 714
1.树的类型定义 typedef struct tnode { char data; struct tnode *lchild,*rchild; }tnode,*tree; 2.树的创建 //先序序列构造二叉树，结点数据类型为字符型，空结点用'#'表示 tnode *creat() { char ch = getchar(); if(ch == '#' || ch =
常见数据结构的基本操作
keavykk的博客
04-11 1306
数组： 添加元素 添加一个元素到数组的最后位置 array.push(item)，返回数组的长度 在数组首位插入一个元素 array.unshift(item) 在指定索引位置插入元素 array.splice(index, 0, item) ...
数据结构之树的基本操作
wolvesqun的专栏
06-23 378
数据结构之树的基本操作 #include #include typedef struct MyBitreeNode {     float data;     struct MyBitreeNode *leftChild;     struct MyBitreeNode *rightChild; }MyBitreeNode; MyBitreeNode*
数据结构之头结点链表的三种插入方式（头插法，尾插法，在pos处插入）
believe_s的博客
07-25 8204
创建头结点，头插法，尾插法，在pos处插入数据
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值