数据结构——树

最新推荐文章于 2019-07-09 10:47:45 发布
最新推荐文章于 2019-07-09 10:47:45 发布
阅读量175 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clusterally/article/details/76684979
版权

头文件：

#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);


#endif  // __TREE_H__

错误信息头文件：

#ifndef __ERROR_H__
#define __ERROR_H__

#include <stdio.h>

#define TRUE           1
#define FALSE          0
#define ERROR         -1
#define MALLOC_ERROR  -2

int errno;     // 错误号

void myError(char *str);

char* myStrError(int num);


#endif // __ERROR_H__

输出错误信息函数：

#include "error.h"

void myError(char *str)
{
    char *msg = myStrError(errno);
    printf ("%s: %s\n", str, msg);
}

char* myStrError(int num)
{
    switch (errno)
    {
        case ERROR:
            return "输入参数错误";    
        case MALLOC_ERROR:
            return "malloc空间分配失败";  
    }
}

功能函数：

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

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

    // 给树结点链表创建头节点
    tree->head = (TreeNode*)malloc(sizeof(TreeNode)/sizeof(char));
    if (tree->head == NULL)
    {
        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;
}

/*
TreeData data;
struct _treeNode *parent;      // 指向父节点的指针          11111111111
struct _treeNode *next;        // 指向链表的下一个结点
struct _childNode *childList;  // 孩子链表的头节点
int degree;                    // 结点的度

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

int Insert_Tree(Tree *tree, TreeData data, int pos)
{
    if (tree == NULL || 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 (node == NULL)
    {   
        errno = MALLOC_ERROR;
        return FALSE;
    }

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

    // 创建该新节点的孩子结点链表的头节点
    node->childList = (ChildNode*)malloc(sizeof(ChildNode)/sizeof(char));
    if (node->childList == NULL)
    {   
        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 (childnode == NULL)
        {
            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 (node == NULL)
        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 (tree == NULL)
        return;

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

void r_delete(Tree *tree, TreeNode *node)
{
    if (tree == NULL || node == NULL)
        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 (parent != NULL)
    {
        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 (tree == NULL || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (pos != 0 && 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 (tree == NULL || pos < 0 || pos > tree->len)
    {
        errno = ERROR;
        return FALSE;
    }

    if (pos != 0 && 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 (tree == NULL)
    {
        errno = ERROR;
        return FALSE;
    }

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

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

    Tree_Clear(tree);

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

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

    return tree->head->next;
}

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

    return tree->len;
}

int r_height(TreeNode* node)
{
    if (node == NULL)
        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 (tree == NULL)
    {
        errno = ERROR;
        return FALSE;
    }

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

    return height;
}

int r_degree(TreeNode* node)
{
    if (node == NULL)
        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 (tree == NULL)
    {
        errno = ERROR;
        return FALSE;
    }

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

    return degree;
}

main函数：

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

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

int main()
{
    Tree *tree = Create_Tree();
    if (tree == NULL)
    {
        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;
}
clusterally
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树公共祖先节点的查找
hero_zouzongling的专栏
05-13 782
#include #include using std::endl; using std::vector; using std::cin; using std::cout; struct treeNode { int value; treeNode*left; treeNode*right; }; bool isAncestor(treeNode*root,treeNode*p) { if(
树的子结构
weixin_30332705的博客
05-28 65
题目：输入两棵二叉树A和B，判断B是不是A的子结构。 思路： 首先判断A树的头结点是否等于B的头结点： 如果相等的话则继续递归判断这两个子节点是否都相同，如果指向B的指针为NULL则返回true，其他情况都返回false（A为NULL，A->data!=B->data） 如果不等的话则继续递归它的左右子树直到NULL。 实现代码如下： #include&lt...
二叉树先序、中序、后序、层序遍历的递归和非递归实现
Shrimp_millet
07-09 247
先序、中序、后序三种递归遍历： //先序遍历 void preOrder(TreeNode* head) { if(!head) return; cout<<head->val<<" "; if(head->left) preOrder(head->left); if(head->right) preOrder(head->righ...
26、二叉搜索树与双向链表
慢慢冲鸭子的博客
06-23 98
题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 leetcode对应：426. 将二叉搜索树转化为排序的双向链表 题目解答 总结：解答的很详细，因为是二叉搜索树，所以左<中<右，这正好是中序遍历的顺序，所以直接用中序遍历解题，这题还要保存一个最左孩子结点（作为新链表的head），一个pre结点...
C语言数据结构——树
01-10
C语言数据结构，树相关知识，整理了一段时间，差不多有个雏形，大家可以参考学习。
自定义数据结构——树 v1.1.zip
06-03
实现了一个自定义的数据结构 —— 树，该自定义结构不同于二叉树及其他数据结构，每个节点的子节点个数不受限制，最大限度保留了数据的原始结构，并实现了其前序和后序遍历的方法。优点是节省了内存，但缺点则是基于...
算法与数据结构教材四(数据结构——树).doc
06-08
算法与数据结构教材四(数据结构——树).doc
数据结构——链表（头指针、头结点）
clusterally的博客
08-05 3399
链表 头指针 头结点
数据结构——链表（头结点循环链表）
clusterally的博客
08-05 576
头结点循环链表
数据结构——链式队列
clusterally的博客
08-05 348
链式队列
数据结构——顺序队列
clusterally的博客
08-05 270
顺序队列
数据结构——链式栈
clusterally的博客
08-05 265
链式栈
数据结构——顺序表
clusterally的博客
08-05 262
顺序表
数据结构——顺序栈
clusterally的博客
08-05 186
顺序栈

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值