数据结构复习：线索二叉树的实现

于 2022-07-29 12:37:30 发布
阅读量308 收藏 2
点赞数
分类专栏： # 数据结构与算法 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rj2017211811/article/details/126053291
版权 
#include <stdio.h>
#include <stdlib.h>

//线索二叉树实现
//利用空闲的n+1个空链域 解决 中序、先序、后序访问序列的 某个结点找前驱 和 找和后继的问题
typedef struct {
    int value;
} ElemType;
typedef struct ThreadNode {
    ElemType data;
    struct ThreadNode *lchild, *rchild;
    int ltag = 0, rtag = 0;//左有标志位 为0的时候为指向左右孩子结点，为1的时候表示指针是线索
    struct ThreadNode *parent;
} BiTNode, ThreadNode, *BiTree, *ThreadTree;

//初始化一颗空树
void InitBiTNode(BiTree &bt) {
    bt = NULL;
}


ThreadNode *pre = NULL;//全局变量 pre 指向当前访问结点的前驱

void visit(ThreadNode *q) {
    printf("%d ", q->data);
    //pre此时指向的是当前访问结点的前驱
    if (q->lchild == NULL) { //当前结点的 左孩子为不存在
        q->lchild = pre; //设置 q 的左线索 指向 pre
        q->ltag = 1;
    }
    if (pre != NULL && pre->rchild == NULL) {//前驱结点的右孩子如果为空
        pre->rchild = q; // 设置前驱结点的 右线索指向 q
        pre->rtag = 1; //修改标志位
    }
    pre = q;
}

//中序线索化
void InThread(ThreadTree &T) {
    if (T != NULL) {
        InThread(T->lchild);
        visit(T);
        InThread(T->rchild);
    }
}

//创建中序线索化
void CreateInThread(ThreadTree T) {
    printf("构建中序线索二叉树\n");
    pre = NULL;//pre指针指向NULL
    if (T != NULL) {
        InThread(T);//中序线索化
        if (pre->rchild == NULL) {//如果最后一个访问结点没有右孩子，设置 右线索为 NULL，同时修改标志位
            pre->rtag = 1;
        }
    }
    printf("\n");
}

//找到p为根的子树中，第一个被中序遍历的结点
ThreadNode *InFirstNode(ThreadNode *p) {
    while (p->ltag == 0) {
        p = p->lchild;
    }
    return p;
}

//中序线索二叉树中找到结点p的后继结点
ThreadNode *InNextNode(ThreadNode *p) {
    if (p->rtag == 0) {
        //中序遍历顺序为左 根 右
        //下一个要访问的结点为 右子树 最左边的结点
        return InFirstNode(p->rchild);//左子树中最左下结点
    } else {
        return p->rchild;
    }
}

//对中序线索二叉树进行中序遍历（利用线索实现的非递归算法）
void Inorder(ThreadNode *T) {

    for (ThreadNode *p = InFirstNode(T); p != NULL; p = InNextNode(p)) {
        printf("%d ", p->data);
    }
    printf("\n");
}

//找到p为根的子树中，最后一个被中序遍历的结点
ThreadNode *InLastNode(ThreadNode *p) {
    while (p->rtag == 0) {
        p = p->rchild;
    }
    return p;
}

//中序线索二叉树中找到结点p的前驱结点
ThreadNode *InPreNode(ThreadNode *p) {
    if (p->ltag == 0) {
        //中序遍历顺序为根 左 右
        //当前结点为结点，前一个被访问的结点为左子树中最靠右的结点
        return InLastNode(p->lchild);//左子树中最左下结点
    } else {
        return p->lchild;
    }
}

//对中序线索二叉树进行逆向中序遍历（利用线索实现的非递归算法）
void RevInorder(ThreadNode *T) {

    for (ThreadNode *p = InLastNode(T); p != NULL; p = InPreNode(p)) {
        printf("%d ", p->data);
    }
    printf("\n");
}

//先序线索化
void PreThread(ThreadTree T) {
    if (T != NULL) {
        visit(T);
        if (T->ltag == 0) {//防止T的指针左指针被修改为前驱线索而产生循环
            PreThread(T->lchild);
        }
        if (T->rtag == 0) {
            PreThread(T->rchild);
        }

    }
}

//创建先序线索化
void CreatePreThread(ThreadTree T) {
    printf("构建先序线索二叉树\n");
    pre = NULL;//pre指针指向NULL
    if (T != NULL) {
        PreThread(T);//中序线索化
        if (pre->rchild == NULL) {//如果最后一个访问结点没有右孩子，设置 右线索为 NULL，同时修改标志位
            pre->rtag = 1;
        }
    }
    printf("\n");
}

//先序线索二叉树中找到结点p的后继结点
ThreadNode *PreNextNode(ThreadNode *p) {
    if (p->rtag == 0) {
        //先序遍历顺序为根 右 左
        //一定有右孩子
        if (p->ltag == 0 && p->lchild != NULL) {//如果有左孩子，先序后继为左孩子
            return p->lchild;
        } else {
            return p->rchild;
        }
    } else { //如果是线索
        return p->rchild;
    }
}

ThreadNode *LeftDeepestNode(ThreadNode *p);

ThreadNode *RightDeepestNode(ThreadNode *p);

//因为先序遍历顺序为根 左 右，所有，如果 p->ltg == 0时候，无法通过找到前驱，需要通过重新遍历或者三叉链表实现
//三叉链表寻找先序线索前驱结点
ThreadNode *PrePreNode(ThreadTree root, ThreadNode *p) {
    if (p->ltag == 0) {
        //4.如果p 是根结点，没有前驱
        if (p == root)
            return NULL;
        if (p->parent != NULL) {
            ThreadNode *parent = p->parent;
            //先序访问顺序:根 左 右
            //1.如果p结点为父结点的左孩子，那么父结点为前驱结点
            //2.如果p结点为右孩子，且左兄弟为NULL，那么父结点为前驱结点
            if (parent->lchild == p ||
                (parent->lchild == NULL && parent->rchild == p)) {
                return parent;
            } else {
                //3.如果p是右孩子，且左兄弟非空
                //找到左兄弟子树中按照先序遍历最后一个访问的结点
                //先往右走，右边没了往左走，左边没了往右走,直到找到最深处的叶子结点
                return RightDeepestNode(parent->lchild);
            }
        } else {
            return NULL;
        }
    } else {
        return p->lchild;
    }
}


//后序线索化
void PostThread(ThreadTree &T) {
    if (T != NULL) {
        PostThread(T->lchild);
        PostThread(T->rchild);
        visit(T);
    }
}

//创建后序线索化
void CreatePostThread(ThreadTree &T) {
    printf("构建后序线索二叉树\n");
    pre = NULL;//pre指针指向NULL
    if (T != NULL) {
        PostThread(T);//中序线索化
        if (pre->rchild == NULL) {//如果最后一个访问结点没有右孩子，设置 右线索为 NULL，同时修改标志位
            pre->rtag = 1;
        }
    }
    printf("\n");
}

//后序线索找前驱
ThreadNode *PostPreNode(ThreadNode *p) {
    if (p->ltag == 0) {
        //p 一定有左孩子
        //因为后序访问顺序为： 左 右 根
        //若p 有右孩子结点q，那么前驱为按照后序遍历最后一个访问的结点
        //如果q没有孩子，那么前驱就是q，如果q有孩子，按照后序遍历访问顺序 左右根，在q这颗子树中，q为根结点，所有前驱是q
        if (p->rtag == 0 && p->rchild != NULL) {
            return p->rchild;
        } else {
            //如果p 没有右孩子，那么前驱为左孩子
            return p->lchild;
        }
    } else {
        return p->lchild;
    }
}


ThreadNode *RightDeepestNode(ThreadNode *p) {
    while (p->rtag == 0) {
        p = p->rchild;
    }
    if (p->ltag == 1) {
        return p;
    } else {
        return LeftDeepestNode(p);
    }

}

ThreadNode *LeftDeepestNode(ThreadNode *p) {
    while (p->ltag == 0) { //寻找最左边的结点
        p = p->lchild;
    }
    if (p->rtag == 1) { // 如果该结点没有右结点
        return p;
    } else {
        return RightDeepestNode(p);
    }
}
//因为后序遍历顺序为左 右 根，所有，如果 p->rtg == 0时候，无法通过找到后继，需要通过重新遍历或者三叉链表实现

//三叉链表寻找后序线索后继结点
ThreadNode *PostPostNode(ThreadTree root, ThreadNode *p) {
    if (p->rtag == 0) {
        //4.如果p 是根结点，没有前驱
        if (p == root)
            return NULL;
        if (p->parent != NULL) {
            ThreadNode *parent = p->parent;
            //后序访问顺序:左 右 根
            //1.如果p结点为父结点的右孩子，那么父结点为前驱结点
            //2.如果p结点为左孩子，且右兄弟为NULL，那么父结点为前驱结点

            if (parent->rchild == p ||
                (parent->rchild == NULL && parent->lchild == p)) {
                return parent;
            } else {
                //3.如果p是左孩子，且右兄弟非空
                //找到右兄弟子树中按照后序遍历第一个访问的结点
                //先往左走，左边没了往右走，右边没了往左走,直到找到最深处的叶子结点
                return LeftDeepestNode(parent->rchild);
            }
        } else {
            return NULL;
        }
    } else {
        return p->rchild;
    }
}

int main() {

    BiTree bt;
    InitBiTNode(bt);

    //插入根结点
    BiTNode *root = (BiTNode *) malloc(sizeof(BiTNode));


    root->data = {1};
    root->lchild = NULL;
    root->rchild = NULL;
    root->ltag = 0;
    root->rtag = 0;

    bt = root;

    BiTNode *t1 = (BiTNode *) malloc(sizeof(BiTNode));
    t1->data = {6};
    t1->ltag = 0;
    t1->rtag = 0;
    root->lchild = t1;

    BiTNode *t11 = (BiTNode *) malloc(sizeof(BiTNode));
    t11->data = {3};
    t11->ltag = 0;
    t11->rtag = 0;

    t1->lchild = t11;
    t11->lchild = NULL;
    t11->rchild = NULL;

    BiTNode *t12 = (BiTNode *) malloc(sizeof(BiTNode));
    t12->data = {9};
    t12->ltag = 0;
    t12->rtag = 0;
    t1->rchild = t12;

    BiTNode *t121 = (BiTNode *) malloc(sizeof(BiTNode));
    t121->data = {8};
    t121->ltag = 0;
    t121->rtag = 0;
    t12->lchild = t121;
    t12->rchild = NULL;

    BiTNode *t1211 = (BiTNode *) malloc(sizeof(BiTNode));
    t1211->data = {7};
    t1211->ltag = 0;
    t1211->rtag = 0;

    t1211->lchild = NULL;
    t1211->rchild = NULL;
    t121->lchild = t1211;
    t121->rchild = NULL;


    BiTNode *t2 = (BiTNode *) malloc(sizeof(BiTNode));
    t2->data = {13};
    t2->ltag = 0;
    t2->rtag = 0;
    root->rchild = t2;

    BiTNode *t21 = (BiTNode *) malloc(sizeof(BiTNode));
    t21->data = {11};
    t21->ltag = 0;
    t21->rtag = 0;
    t2->lchild = t21;


    BiTNode *t211 = (BiTNode *) malloc(sizeof(BiTNode));
    t211->data = {10};
    t211->ltag = 0;
    t211->rtag = 0;
    t21->lchild = t211;
    t211->lchild = NULL;
    t211->rchild = NULL;

    t21->rchild = NULL;

    BiTNode *t22 = (BiTNode *) malloc(sizeof(BiTNode));
    t22->data = {14};
    t22->ltag = 0;
    t22->rtag = 0;
    t2->rchild = t22;
    t22->lchild = NULL;
    t22->rchild = NULL;

    root->parent = NULL; //1
    t1->parent = root;//1->6 左
    t2->parent = root;//1->13 右

    t11->parent = t1;//6->3 左
    t12->parent = t1;//6->9 有
    t121->parent = t12; //9->8 左
    t1211->parent = t121;//8->7 左

    t21->parent = t2;//13->11 左
    t22->parent = t2;//13->14 右
    t211->parent = t21;//11->10 左





    ThreadNode *t0 = t121;


//    CreateInThread(bt);
//    ThreadNode *n1 = InPreNode( t0);
//    ThreadNode *n2 = InNextNode(t0);
//    if (n1 != NULL && n2 != NULL) {
//        printf("%d 的线索前驱结点：%d，线索后继结点：%d\n", t0->data, n1->data, n2->data);
//    } else if (n1 == NULL && n2 != NULL) {
//        printf("%d 的线索后继结点：%d\n", t0->data, n2->data);
//    } else if (n1 != NULL && n2 == NULL) {
//        printf("%d 的线索前驱结点：%d\n", t0->data, n1->data);
//    }
//    printf("对中序线索二叉树进行中序遍历（利用线索实现的非递归算法):\n");
//    Inorder(bt);
//    printf("对中序线索二叉树进行逆向中序遍历（利用线索实现的非递归算法):\n");
//    RevInorder(bt);



//    CreatePreThread(bt);
//    ThreadNode *n1 = PrePreNode(root, t0);
//    ThreadNode *n2 = PreNextNode(t0);
//
//    if (n1 != NULL && n2 != NULL) {
//        printf("%d 的线索前驱结点：%d，线索后继结点：%d\n", t0->data, n1->data, n2->data);
//    } else if (n1 == NULL && n2 != NULL) {
//        printf("%d 的线索后继结点：%d\n", t0->data, n2->data);
//    } else if (n1 != NULL && n2 == NULL) {
//        printf("%d 的线索前驱结点：%d\n", t0->data, n1->data);
//    }



    CreatePostThread(bt);
    ThreadNode *n1 = PostPreNode(t0);
    ThreadNode *n2 = PostPostNode(root, t0);

    if (n1 != NULL && n2 != NULL) {
        printf("%d 的线索前驱结点：%d，线索后继结点：%d\n", t0->data, n1->data, n2->data);
    } else if (n1 == NULL && n2 != NULL) {
        printf("%d 的线索后继结点：%d\n", t0->data, n2->data);
    } else if (n1 != NULL && n2 == NULL) {
        printf("%d 的线索前驱结点：%d\n", t0->data, n1->data);
    }
    return 0;
}
I like study.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线索二叉树的建立、删除、插入、恢复线索
06-29
线索二叉树的建立 删除 插入 恢复线索
数据结构之线索二叉树的简单实现
qq_43060759的博客
10-21 222
二叉树的链式存储时会有较多空间的浪费，当一颗有 n 个节点的二叉树存储共有2n个指针域，但是只有n-1个被用到，所以剩下的n+1个都会被浪费掉，因此可以想一种办法把剩余的空间利用起来，线索二叉树应运而生。 将二叉树重新定义如下每个节点为下列形式 lchild ltag data rtag rchild 其中：ltag=0 时lchild指向左子女； ltag=1 时lchild指向前驱； rtag...
数据结构 线索二叉树 原理及实现
旧时光
11-16 2184
通过考察各种二叉链表，不管儿叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共有2n个链域，非空链域为n-1个，但其中的空链域却有n+1个。如下图所示。     因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。     记ptr指向二叉链表中的一个结点，以下是建立线索的规则：     （1）如果ptr->lc
数据结构（8）线索二叉树的介绍以及代码实现
it_is_me_a的博客
08-24 282
这篇文章我们接着讲二叉树。 文章目录1. 二叉树遍历--先序遍历、中序遍历、后序遍历和层次遍历1. 先序遍历：ABDEGHCF2. 中序遍历：DBGEHAFC3. 后序遍历：DGHEBFCA4. 层次遍历：ABCDEFGH2. 线索二叉树的定义3. 二叉树的线索化1. 二叉树的线索化代码实现4. 线索二叉树的基本运算 1. 二叉树遍历–先序遍历、中序遍历、后序遍历和层次遍历 所谓二叉树的遍历，是指...
数据结构——线索二叉树（代码）
地址ch3nye.top
10-29 527
线索二叉树 C++ 环境codeblocks17 通过 /* 线索二叉树 @CGQ 2018/10/29 */ #include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; using namespace std; #define ElemType char typedef struct BiTN...
python数据结构：求二叉树深度
12-22
1.代码实现 class BinaryTreeNode(object): # 创建二叉树结点的函数 def __init__(self): self.data = '#' self.LChild = None self.RChild = None class BinaryTree(object): # 创建二叉树的函数 def ...
数据结构笔记：二叉树
01-20
二叉树：每个节点最多含有两个子树的树称为二叉树 二叉树的性质 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 深度为k的二叉树至多有2^k-1个结点（k>0） 对于任意一棵二叉树，如果其叶结点为N0，而度数为2的结点...
python数据结构：求二叉树节点个数
01-21
2.实现代码 class BinaryTreeNode(object): # 创建二叉树结点的函数 def __init__(self): self.data = '#' self.LChild = None self.RChild = None class BinaryTree(object): #创建二叉树的函数 def ...
C语言数据结构之线索二叉树及其遍历
08-29
主要介绍了C语言数据结构之线索二叉树及其遍历的相关资料,为了加快查找节点的前驱和后继。对二叉树的线索化就是对二叉树进行一次遍历，在遍历的过程中检测节点的左右指针是否为空，如果是空，则将他们改为指向前驱和...
数据结构之线索二叉树-C语言实现.pdf
最新发布
01-15
线索二叉树 数据结构学习笔记——线索二叉树
线索二叉树的插入，删除
05-26
一、内容 线索二叉树的应用。实现线索二叉树的建立、插入、删除、恢复线索的实现。
线索二叉树的应用
gong_zc的博客
07-01 1043
前提：为什么要有线索二叉树这个东东？？？？？？ 答：利用原来二叉树的n+1个空位建立线索机制，方便查找前驱和后继。问：可以不学吗？答：不学是不行的，因为考试要考啊。。。。 接下来让我们看看代码吧。。。 结构体： 有了结构体干什么呢，当然先建个树玩玩呗。 创建线索二叉树： 问：为什么要加祖先节点呢？答：等会会用到的。。。建就对了，干就完了！！！奥力给 先序线索树的构建：相当于先序遍历一次树，当发现有空域时对树绑定前驱或后继，并进行标记，后面也差不多了。。代码： 问：为什么要在递归的时候判断lta
线索二叉树创建及删除
weixin_33708432的博客
08-21 470
题目描写叙述 线索二叉树概念 1．定义 　n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前趋和后继结点的指针（这样的附加的指针称为”线索”）。 这样的加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。依据线索性质的不同，线索二叉树可分为前序线索二叉树、中...
二叉查找树的实现（四）——线索树的建立
Serve it
11-26 614
       首先，我们探讨一下为什么要建立线索树，两点原因： （1）在之前我们探讨过二叉树的中序遍历，中序遍历的顺序是LVR，也就是访问完左节点后再回来访问中间节点，也就是说中间节点作为左节点的后继节点，但是问题在于左节点是中间节点的子节点，而我们不可能直接通过二叉树的子节点去访问父节点，这并不是一个可逆的操作。遍历操作中是通过栈结构完成这种操作的，那么我们能不能不用栈实现这种操作呢？ （2...
线索二叉树的创建
weixin_42051691的博客
08-16 1304
一、什么是线索二叉树 从树的节点类型可以看出，每个节点包含三个部分，lchild data rchild，如果一个节点中没有左右孩子那么lchild 和 rchild中存放的就是空造成资源浪费。 而空指针的个数也是可以计算出来的：节点个数为n 。除了根节点，每个节点都被前驱节点指向，因此消耗的指针个数n-1，剩余的空指针个数为 2n-(n-1)=n+1 这时就想到利用这些指针对树进行线索化。 二、中序创建线索二叉树代码 typedef struct BiThrNode { TElemType data;
C语言：中序线索二叉树的相关算法
qq_40994908的博客
12-11 1117
写出中序线索二叉树中查找指定结点*p中序后继的算法。
中序线索二叉树的插入
废柴三小姐
05-08 3234
中序全线索二叉树的插入 原题要求：试写一个算法，在中序全线索二叉树的结点*p之下，插入一棵以结点*x为根、只有左子树的中序全线索二叉树，使*x为根的二叉树称为*p的左子树。若*p原来有左子树，则令它为*x的右子树。完成插入之后的二叉树应保持全线索化特性。 #include <iostream> #define ERROR 0 #define OK 1 #include"stdlib.h...
串的基本操作(c语言)
热门推荐
rj2017211811的博客
12-20 1万+
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAX_NUM 100 typedef struct str{ char ch[MAX_NUM+1]; int length; }*SString; //字符串初始化 SString initSString() { SString str=(SStr...
栈的应用之括号匹配（c语言）
rj2017211811的博客
10-07 9475
#include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #define MAXSIZE 100 //***栈的应用之括号匹配***/ typedef struct { char data[MAXSIZE]; int top; }*sqStack,sepStack; sqStack init
数据结构:线索二叉树中序遍历
06-08
线索二叉树是对普通二叉树的改进，将原本为空的左孩子指针或右孩子指针改为指向该节点在中序遍历下的前驱或后继节点。这样可以方便地在不需要使用递归或栈的情况下进行遍历。 中序遍历线索二叉树的过程如下： 1. 从...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值