线索化二叉树

最新推荐文章于 2022-05-07 18:56:20 发布
最新推荐文章于 2022-05-07 18:56:20 发布
阅读量116 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meng110389/article/details/109212625
版权
本文介绍了如何使用线索化二叉树的技巧，通过叶子节点的空左指针和线性表来高效访问和遍历二叉树。实例展示了BTree结构的创建、插入、删除和遍历操作，以及如何将操作应用到SeqList上进行线性存储与操作。
摘要由CSDN通过智能技术生成

基本思想

线索化二叉树指的是将二叉树中的结点进行逻辑意义上的重排序，使其可以线性的方式访问每一个结点

实现方式

  1. 利用叶子结点空的左指针域，使其指向前序遍历的后继结点
  2. 利用线性表保存二叉树的遍历顺序

代码实现

BTree.h

#ifndef _BTREE_H_
#define _BTREE_H_

#define BT_LEFT 0
#define BT_RIGHT 1

typedef void BTree;
typedef unsigned long long BTPos;

typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
    BTreeNode* left;
    BTreeNode* right;
};

typedef void (BTree_Printf)(BTreeNode*);

BTree* BTree_Create();

void BTree_Destroy(BTree* tree);

void BTree_Clear(BTree* tree);

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Root(BTree* tree);

int BTree_Height(BTree* tree);

int BTree_Count(BTree* tree);

int BTree_Degree(BTree* tree);

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);

#endif



BTree.c

#include <stdio.h>
#include <malloc.h>
#include "BTree.h"

typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;
    BTreeNode* root;
};

static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;

    if ((node != NULL) && (pFunc != NULL))
    {
        for (i = 0; i < format; i++)
        {
            printf("%c", div);
        }

        pFunc(node);

        printf("\n");

        if ((node->left != NULL) || (node->right != NULL))
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else
    {
        for (i = 0; i < format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}

static int recursive_count(BTreeNode* root) // O(n)
{
    int ret = 0;

    if (root != NULL)
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);
    }

    return ret;
}

static int recursive_height(BTreeNode* root) // O(n)
{
    int ret = 0;

    if (root != NULL)
    {
        int lh = recursive_height(root->left);
        int rh = recursive_height(root->right);

        ret = ((lh > rh) ? lh : rh) + 1;
    }

    return ret;
}

static int recursive_degree(BTreeNode* root) // O(n)
{
    int ret = 0;

    if (root != NULL)
    {
        if (root->left != NULL)
        {
            ret++;
        }

        if (root->right != NULL)
        {
            ret++;
        }

        if (ret == 1)
        {
            int ld = recursive_degree(root->left);
            int rd = recursive_degree(root->right);

            if (ret < ld)
            {
                ret = ld;
            }

            if (ret < rd)
            {
                ret = rd;
            }
        }
    }

    return ret;
}

BTree* BTree_Create() // O(1)
{
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

    if (ret != NULL)
    {
        ret->count = 0;
        ret->root = NULL;
    }

    return ret;
}

void BTree_Destroy(BTree* tree) // O(1)
{
    free(tree);
}

void BTree_Clear(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;

    if (btree != NULL)
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag) // O(n) 
{
    TBTree* btree = (TBTree*)tree;
    int ret = (btree != NULL) && (node != NULL) && ((flag == BT_LEFT) || (flag == BT_RIGHT));
    int bit = 0;

    if (ret)
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;

        node->left = NULL;
        node->right = NULL;

        while ((count > 0) && (current != NULL))
        {
            bit = pos & 1;
            pos = pos >> 1;

            parent = current;

            if (bit == BT_LEFT)
            {
                current = current->left;
            }
            else if (bit == BT_RIGHT)
            {
                current = current->right;
            }

            count--;
        }

        if (flag == BT_LEFT)
        {
            node->left = current;
        }
        else if (flag == BT_RIGHT)
        {
            node->right = current;
        }

        if (parent != NULL)
        {
            if (bit == BT_LEFT)
            {
                parent->left = node;
            }
            else if (bit == BT_RIGHT)
            {
                parent->right = node;
            }
        }
        else
        {
            btree->root = node;
        }

        btree->count++;
    }

    return ret;
}

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL;
    int bit = 0;

    if (btree != NULL)
    {
        BTreeNode* parent = NULL;
        BTreeNode* current = btree->root;

        while ((count > 0) && (current != NULL))
        {
            bit = pos & 1;
            pos = pos >> 1;

            parent = current;

            if (bit == BT_LEFT)
            {
                current = current->left;
            }
            else if (bit == BT_RIGHT)
            {
                current = current->right;
            }

            count--;
        }

        if (parent != NULL)
        {
            if (bit == BT_LEFT)
            {
                parent->left = NULL;
            }
            else if (bit == BT_RIGHT)
            {
                parent->right = NULL;
            }
        }
        else
        {
            btree->root = NULL;
        }

        ret = current;

        btree->count = btree->count - recursive_count(ret);
    }

    return ret;
}

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL;
    int bit = 0;

    if (btree != NULL)
    {
        BTreeNode* current = btree->root;

        while ((count > 0) && (current != NULL))
        {
            bit = pos & 1;
            pos = pos >> 1;

            if (bit == BT_LEFT)
            {
                current = current->left;
            }
            else if (bit == BT_RIGHT)
            {
                current = current->right;
            }

            count--;
        }

        ret = current;
    }

    return ret;
}

BTreeNode* BTree_Root(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL;

    if (btree != NULL)
    {
        ret = btree->root;
    }

    return ret;
}

int BTree_Height(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if (btree != NULL)
    {
        ret = recursive_height(btree->root);
    }

    return ret;
}

int BTree_Count(BTree* tree) // O(1)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if (btree != NULL)
    {
        ret = btree->count;
    }

    return ret;
}

int BTree_Degree(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;

    if (btree != NULL)
    {
        ret = recursive_degree(btree->root);
    }

    return ret;
}

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div) // O(n)
{
    TBTree* btree = (TBTree*)tree;

    if (btree != NULL)
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

SeqList.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

SeqList.c

#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList
{
    int capacity;
    int length;
    TSeqListNode* node;
} TSeqList;

SeqList* SeqList_Create(int capacity) // O(1)
{
    TSeqList* ret = NULL;

    if (capacity >= 0)
    {
        ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);
    }

    if (ret != NULL)
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->node = (TSeqListNode*)(ret + 1);
    }

    return ret;
}

void SeqList_Destroy(SeqList* list) // O(1)
{
    free(list);
}

void SeqList_Clear(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;

    if (sList != NULL)
    {
        sList->length = 0;
    }
}

int SeqList_Length(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if (sList != NULL)
    {
        ret = sList->length;
    }

    return ret;
}

int SeqList_Capacity(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if (sList != NULL)
    {
        ret = sList->capacity;
    }

    return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
    TSeqList* sList = (TSeqList*)list;
    int ret = (sList != NULL);
    int i = 0;

    ret = ret && (sList->length + 1 <= sList->capacity);
    ret = ret && (0 <= pos);

    if (ret)
    {
        if (pos >= sList->length)
        {
            pos = sList->length;
        }

        for (i = sList->length; i > pos; i--)
        {
            sList->node[i] = sList->node[i - 1];
        }

        sList->node[i] = (TSeqListNode)node;

        sList->length++;
    }

    return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = NULL;

    if ((sList != NULL) && (0 <= pos) && (pos <= sList->length))
    {
        ret = (SeqListNode*)(sList->node[pos]);
    }

    return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = SeqList_Get(list, pos);
    int i = 0;

    if (ret != NULL)
    {
        for (i = pos + 1; i < sList->length; i++)
        {
            sList->node[i - 1] = sList->node[i];
        }

        sList->length--;
    }

    return ret;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "BTree.h"
#include "SeqList.h"


struct Node
{
    BTreeNode header;
    char v;
};

void printf_data(BTreeNode* node)
{
    if (node != NULL)
    {
        printf("%c", ((struct Node*)node)->v);
    }
}

void threaded_binary_tree_by_left(BTreeNode* root, BTreeNode** pp) 
{
    if (root!=NULL && pp!=NULL) {
        if (*pp!=NULL) {
           (*pp)->left = root;
            *pp = NULL;
        }
        if (root->left == NULL) {
            *pp = root;
        }
        threaded_binary_tree_by_left(root->left, pp);
        threaded_binary_tree_by_left(root->right, pp);
    }
}

void threaded_binary_tree_by_list(BTreeNode* root, SeqList* list)
{
    if (root!=NULL && list!=NULL) {
        SeqList_Insert(list, (SeqListNode*)root, SeqList_Length(list));
        threaded_binary_tree_by_list(root->left, list);
        threaded_binary_tree_by_list(root->right, list);
    }
}


int main(int argc, char* argv[])
{
    int i = 0;
    BTree* tree = BTree_Create();
    BTreeNode* current = NULL;
    BTreeNode* p = NULL;
    SeqList* list = NULL;
  

    struct Node n1 = { {NULL, NULL}, 'A' };
    struct Node n2 = { {NULL, NULL}, 'B' };
    struct Node n3 = { {NULL, NULL}, 'C' };
    struct Node n4 = { {NULL, NULL}, 'D' };
    struct Node n5 = { {NULL, NULL}, 'E' };
    struct Node n6 = { {NULL, NULL}, 'F' };

    BTree_Insert(tree, (BTreeNode*)&n1, 0, 0, 0);
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);

    printf("Full Tree: \n");

    BTree_Display(tree, printf_data, 4, '-');

    printf("\n");
    
    printf("通过叶子节点空的左指针实现线索化二叉树\n");

    current = BTree_Root(tree);
    threaded_binary_tree_by_left(current, &p);

    while (current !=NULL) {
        printf("%c, ", ((struct Node*)current)->v);
        current = current->left;
    }
    printf("\n");

    printf("通过线性表保存二叉树的遍历顺序\n");
    list = SeqList_Create(BTree_Count(tree));
    threaded_binary_tree_by_list(BTree_Root(tree), list);
    for (i = 0; i < SeqList_Length(list); ++i) {
        printf("%c, ", ((struct Node*)SeqList_Get(list, i))->v);
    }
    printf("\n");
    BTree_Destroy(tree);

    return 0;
}

运行结果

Full Tree:
A
----B
--------D
--------E
------------F
------------
----C

通过叶子节点空的左指针实现线索化二叉树
A, B, D, E, F, C,
通过线性表保存二叉树的遍历顺序
A, B, D, E, F, C,
写一行代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线索化二叉树C实现代码
02-24
线索化二叉树是一种特殊的二叉树数据结构，它的主要目的是为了在非递归的情况下能够进行二叉树的前序、中序和后序遍历。这种数据结构通过利用二叉树结点中的空指针域，即通常的`left`和`right`指针，来附加线索，...
线索化二叉树的实现
05-01
"线索化二叉树的实现" 在计算机科学中，二叉树是一种重要的数据结构，它广泛应用于各种领域，如数据库、文件系统、编译器等。线索化二叉树是一种特殊的二叉树，它在二叉树的每个节点中添加了指向其前驱和后继节点的...
树：线索化二叉树
zp_zhang的博客
07-18 449
1，线索化二叉树基本介绍 线索化二叉树是对普通二叉树的扩展，对于普通二叉树而言，一个节点会包含一个数据域以及指向左右子节点的位置索引；但是对于叶子节点来讲，左右子节点的位置索引并没有被利用到，线索二叉树充分利用该部分节点，普通二叉树如下： 在n个节点的二叉树中总共含有n - 1（类似5指向2表示一个位置指向）个位置指向，即2n（每一个节点有左右两个指针域）个指针域，这样对于一个二叉树来讲，共有2n - (n - 1) = n + 1个空指针域。利用二叉树的空指针域，根据前/中/后序不同遍历方式存储前驱节
数据结构之二叉树的创建
业精于勤荒于嬉
05-07 4429
创建二叉树 首先定义相关结构体及其他变量 #define BT_LEFT 0 // 左边 #define BT_RIGHT 1 // 右边 // 定义新数据类型，用于封装函数 typedef void BTree; typedef unsigned long long BTPos; // 定义二叉树左右指针结构体 typedef struct _tag_BTreeNode BTreeNode; struct _tag_BTreeNode { BT...
二叉树--前序遍历、中序遍历、后序遍历、层次遍历
daa20的专栏
04-07 316
//BTree.h #ifndef _BTREE_H_ #define _BTREE_H_ #define BT_LEFT 0 #define BT_RIGHT 1 typedef unsigned long long BTPos; //64bit typedef void BTree; typedef struct _tag_BTreeNode BTreeNode; /
数据结构-二叉树
z251941074的专栏
09-08 1022
数据结构 二叉树实现算法
线索化二叉树及其遍历
qq_44300280的博客
05-07 794
线索化二叉树及其遍历
线索化二叉树的作用
学Java，找哪吒
08-16 1万+
一、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树。 问题分析： 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}。 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上。 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，要怎么办？ 解决方案 --> 线索化二叉树 二、线索化二叉树 1、n个节点的二叉树链表总含有n+1（公式2n-(n-1)=n+1）个空指针域。...
中序线索化二叉树
热门推荐
waldeinNJU的博客
10-26 2万+
中序线索化二叉树1. 简介2. 中序线索化的方法3. 代码详细4. 测试 1. 简介 对于二叉树来说，只能是很直观地知道某个节点及其左右子节点，但是如果想知道此节点按照某种方式遍历时的前一个节点（前继节点）和后一个节点（后继节点）的话，就不得不按照此种遍历方式对二叉树遍历一次，只有这样才能知道前继或后继节点。因此，==为了避免这种不得不遍历的麻烦，是否可以寻找一种简便的方式从而更快地获取某节点的前继或后继节点？==我认为这是对二叉树线索化的主要原因。 另一方面是涉及到资源利用的问题。如上图所示，二叉树共有
Java版线索化二叉树
qq_37837621的博客
03-06 1132
文章收藏的好句子：当你足够强大，就能轻松抵挡住命运给的打击和考验。目录1、线索化二叉树1、线索化二叉树在介绍线索化二叉树之前，我们先看一个案例，我先画一棵二叉树，如图1所示：如果我们对图1...
中序线索化二叉树的非递归算法.doc
09-12
中序线索化二叉树的非递归算法 中序线索化二叉树的非递归算法是指对二叉树进行中序遍历，并将其转换为线索化二叉树的算法。这里，我们将详细介绍该算法的实现过程和相关知识点。 算法思想 中序线索化二叉树的非...
中序线索化二叉树.zip
12-04
中序线索化二叉树是一种特殊的二叉树数据结构，它的目的是为了在二叉树上实现快速的中序遍历。在普通的二叉树中，中序遍历通常需要借助栈或递归来完成，而线索化二叉树通过添加额外的线索（thread）指向其前驱或后继...
中序线索化二叉树的c++代码
11-19
个人认为比较简洁 使用递归方式 创建使用扩展二叉树更加便捷 且有部分先序线索化代码 不够完善
二叉树的线索化 二叉树
12-05
二叉树的线索化
中序线索化二叉树及中序遍历
04-01
在实际应用中，为了在非递归情况下高效地进行中序遍历，引入了线索二叉树的概念，特别是中序线索化二叉树。 中序线索化二叉树是在二叉链表的基础上进行修改，使得在任何时刻，通过线索可以确定某个节点是前驱还是...
Java线索化二叉树数据结构.docx
07-03
### Java线索化二叉树数据结构 #### 一、引言 在计算机科学领域，二叉树作为一种重要的数据结构，在很多算法中都有广泛的应用。为了提高查找效率，一种改进的数据结构——线索二叉树被引入。本文将详细介绍线索...
C语言实现的线索化二叉树及其遍历
本篇文章详细介绍了如何在C语言环境下实现线索化二叉树的数据结构和算法。线索化二叉树是一种特殊的二叉树存储结构，通过额外的信息（线索）来辅助遍历操作，使得在遍历时可以更方便地追踪前驱和后继节点，从而简化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值