先序，中序，后序线索化二叉树

最新推荐文章于 2025-03-18 16:31:20 发布
最新推荐文章于 2025-03-18 16:31:20 发布
阅读量6.4k 收藏 54
点赞数 13
分类专栏： 数据结构与算法 文章标签： 数据结构
本文介绍了一种基于先序、中序和后序遍历的二叉树线索化实现方法，并提供了完整的C++代码示例。通过加入头结点实现了二叉树的线索化过程，包括求结点的前驱和后继结点等操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本文是作者整理网上代码得到！
输入先序序列：ABDH##I##EJ###CF##G## 

#include <stdio.h>
#include <malloc.h>
#include <iostream>
#define max 100

using namespace std;

typedef char datatype;
typedef enum PointerTag { Link, Thread };
struct node
{
    struct node *lchild;
    struct node *rchild;
    datatype data;
    //int level;//层级
    PointerTag ltag;
    PointerTag rtag;
};
typedef struct node *BTREE;


void CreateBT(BTREE &T)//建树，按先序顺序输入节点
{
    char ch;
    scanf_s("%c", &ch);
    if (ch == '#')
    {
        T = NULL;
        return;
    }
    else
    {
        T = (BTREE)malloc(sizeof(node));
        if (!T)
            exit(1);
        T->data = ch;
        T->ltag = Link;
        T->rtag = Link;
        CreateBT(T->lchild);
        CreateBT(T->rchild);
    }
}

BTREE pre = (node*)malloc(sizeof(node));
//实现二叉链表的先序线索化；
void PreThreading(BTREE P) {
    if (P) {

        if (!P->lchild) {
            P->ltag = Thread;
            P->lchild = pre;
        }
        else P->ltag = Link;

        if (!pre->rchild) {
            pre->rtag = Thread;
            pre->rchild = P;
        }
        else P->rtag = Link;

        pre = P;
        if (Link == P->ltag)
            PreThreading(P->lchild);
        if (Link == P->rtag)
            PreThreading(P->rchild);
    }
}

//加入头结点,先序线索二叉树
void PreOrderThread_Head(BTREE &head, BTREE &P) {
    head = (node*)malloc(sizeof(BTREE));
    head->rchild = head;//右指针回指
    head->ltag = Link;
    head->rtag = Thread;//建立头结点
    if (!P) {
        head->lchild = head;//空树
    }
    else {
        head->lchild = P;
        pre = head;
        PreThreading(P);//先序遍历进行先序线索化
        pre->rtag = Thread;
        pre->rchild = head;
        head->rchild = pre;
    }
}
//求先序线索二叉树中结点p 的先序顺序的后继结点p*
BTREE PreNext(BTREE p)
{
    BTREE q;
    if (p->ltag == Link) q = p->lchild;
    else  q = p->rchild;
    return q;
}
//实现先序线索链表的先序遍历。
void ForOrderTraverse_Thr(BTREE T) {
    BTREE p = T->lchild;
    while (p != T)
    {
        printf("%c", p->data);
        p = PreNext(p);
    }
}
//----------------------------------------------------------------------------------------------------------------------------
//实现二叉链表的中序线索化；
void InThreading(BTREE P) {
    if (P) {
        InThreading(P->lchild);
        if (!P->lchild) {
            P->ltag = Thread;
            P->lchild = pre;
        }
        else P->ltag = Link;

        if (!pre->rchild) {
            pre->rtag = Thread;
            pre->rchild = P;
        }
        else P->rtag = Link;
        pre = P;
        InThreading(P->rchild);
    }
}
//加入头结点,中序线索二叉树
void InOrderThread_Head(BTREE &head, BTREE &P) {
    head = (node*)malloc(sizeof(BTREE));
    head->rchild = head;//右指针回指
    head->ltag = Link;
    head->rtag = Thread;//建立头结点
    if (!P) {
        head->lchild = head;//空树
    }
    else {
        head->lchild = P;
        pre = head;
        InThreading(P);//中序遍历进行中序线索化
        pre->rtag = Thread;
        pre->rchild = head;
        head->rchild = pre;
    }
}
//在中序线索二叉树中求一个结点p的中序后继p$
BTREE InNext(BTREE p)
{
    BTREE q;
    if (p->rtag == Thread)
    {
        q = p->rchild;
    }
    else
    {
        q = p->rchild;
        while (q->ltag == Link) q = q->lchild;//右子树的最左节点
    }
    return q;
}
//实现中序线索链表的中序遍历。
void InOrderTraverse_Thr(BTREE T) {
    BTREE p = T->lchild;

    while (p->ltag == Link)
    {
        p = p->lchild;
    }
    while (p != T)
    {
        printf("%c", p->data);
        p = InNext(p);
    }
}
//-------------------------------------------------------------------------------------------------------------------------------------

//实现二叉链表的后序线索化；
void PostThreading(BTREE P) {
    if (P) {
        if (Link == P->ltag)
            PostThreading(P->lchild);
        if (Link == P->rtag)
            PostThreading(P->rchild);

        if (!P->lchild) {
            P->ltag = Thread;
            P->lchild = pre;
        }
        else P->ltag = Link;

        if (!pre->rchild) {
            pre->rtag = Thread;
            pre->rchild = P;
        }
        else P->rtag = Link;
        pre = P;

    }
}
//加入头结点,后序线索二叉树
void PostOrderThread_Head(BTREE &head, BTREE &P) {
    head = (node*)malloc(sizeof(BTREE));
    head->rchild = head;//右指针回指
    head->ltag = Link;
    head->rtag = Thread;//建立头结点
    if (!P) {
        head->lchild = head;//空树
    }
    else {
        head->lchild = P;
        pre = head;
        PostThreading(P);//后序遍历进行后序线索化
        head->rchild = pre;
    }
}
//在后序线索二叉树中求一个结点p的父节点
BTREE parent(BTREE &T, BTREE    &p)
{
    BTREE    temp;
    temp = T;
    if (temp->lchild == p)
        return temp;    //父节点是头结点
    else
    {
        temp = temp->lchild;
        while (temp->lchild != p && temp->rchild != p)
        {
            if (Link == temp->rtag)
                temp = temp->rchild;    //如果节点有右节点，那么往右
            else
                temp = temp->lchild;    //如果节点没有右孩子，那么去左孩子，没有左孩子，去前驱，也是走往左
        }
        return temp;
    }
}
//求后序线索二叉树中结点p 的后序顺序的后继结点p*
BTREE PostNext(BTREE &T,BTREE &p)
{
    BTREE par;
    par = parent(T, p);    //parent是p的双亲:
    if (T == par)    return T;    //1.若parent是T，即p是根节点，则无后继
    else if (p == par->rchild || Thread == par->rtag)    //2.若p是双亲的右孩子，或者是独生左孩子，则后继为双亲
        return par;
    else
    {
        while (par->rtag == Link)        //3.若p是有兄弟的左孩子，则后继为双亲的右子树上按照后续遍历访问的第一个节点。
        {
            par = par->rchild;
            while (par->ltag == Link)
            {
                par = par->lchild;
            }
        }
        return par;
    }   
}
//实现后序线索链表的后序遍历。
void PostOrderTraverse_Thr(BTREE T) {
    BTREE p = T->lchild;
    while (1)
    {
        while (Link == p->ltag)     p = p->lchild;
        if (Link == p->rtag)    p = p->rchild;
        else    break;        //p指向第一个被访问的节点
    }
    while (p != T)
    {
        printf("%c", p->data);
        p = PostNext(T,p);
    }
}


int  main()
{
    BTREE a, s;
    pre->rtag = Thread;
    pre->rchild = NULL;
    printf("先序建立二叉链表，请输入： ");
    CreateBT(a);
    int i;
    printf("输入1先序线索化，输入2中序线索化，输入3后序线索化: ");
    scanf_s("%d", &i);
    getchar();
    if (i == 1) {
        printf("先序线索化ing\n");
        PreOrderThread_Head(s, a);

        printf("先序线索化后先序输出此树：");
        ForOrderTraverse_Thr(s); printf("\n");
    }
    else if (i == 2)
    {
        printf("中序线索化ing\n");
        InOrderThread_Head(s, a);

        printf("中序线索化后先序输出此树：");
        InOrderTraverse_Thr(s); printf("\n");
    }
    else {
        printf("后序线索化ing\n");
        PostOrderThread_Head(s, a);

        printf("后序线索化后先序输出此树：");
        PostOrderTraverse_Thr(s); printf("\n");
    }

    system("pause");
    return 0;
}

输出：


数据结构（十七） -- C语言版 -- 树 - 二叉树的线索化及遍历 -- 先序线索化、中序线索化、后序线索化
青椒*^_^*凤爪爪的博客
06-20 2万+
在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
【数据结构】-线索二叉树(后序)
RunningSnail的博客
08-11 4588
后序线索化二叉树1.头文件及类型定义2.线索二叉树结点类型定义3.函数声明4.基本操作4.1 先序建立线索二叉树4.2 初始化tag4.3 后序线索化二叉树4.3.1 访问并建立线索4.3.2 遍历4.3.3 后序线索化主过程4.4 寻找后序前驱4.5 逆向后序遍历4.5.1 打印结点4.5.2 利用后序前驱实现逆向后序遍历4.6 main函数4.7 测试4.7.1 二叉树结构4.7.2 测试结果5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdl
二叉树的前序、中序和后序线索化
weixin_33877092的博客
04-25 224
二叉树是一种非线性结构，遍历二叉树需要通过递归或者用栈辅助实现非递归的遍历。 用二叉树作为压缩存储结构时，取到一个结点，只能获取节点的左孩子和右孩子，不能直接得到结点的任一遍历序列的前驱或者后继。为了实现这种遍历，偶们利用二叉树中指向左右子树的空指针来存放结点的前驱和后继。线索化二叉树思路： 当某一结点的左结点或结右点存在NULL时，则该结点的为空的子结点...
二叉树前序中序后续线索树_Java实现线索化二叉树并遍历（前序，中序，后序）...
weixin_36376992的博客
01-14 134
/*** 线索化二叉树的节点*/public class IndexNode {public int id;public String name;public IndexNode left;public IndexNode right;public IndexNode parent = null; // 后序线索化的时候需要使用public boolean isLeftIndexed; // 0...
线索二叉树（中序）
sinat_31089473的博客
08-16 5106
将数列{1 ，3 ，6， 8 ，10 ，14}构建成一颗二叉树 1）n个结点的二叉链表中含有n+1 [公式2n-(n-1)=n+1] 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"） 2）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树（Threaded BinaryTree）。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 3）一个结点的前一个结点，称为前驱结点 4）一个
二叉树：中序线索二叉树
weixin_58707952的博客
11-29 395
#include<iostream> using namespace std; typedef struct BiNode { int data; BiNode* lchild, * rchild; int ltag, rtag; }; //中序线索链表的建立 void InThread(BiNode* p) { static BiNode* pre = NULL; if (p == NULL) return; InThread(p->lchild); //左子树线.
线索二叉树(中序、先序和后序及遍历)
12-21
遍历后序线索二叉树，从任意节点开始，可以通过线索找到左子树的最后一个节点，然后找到右子树的最后一个节点，最后访问根节点。 总结来说，线索二叉树通过增加线索信息，使得二叉树的遍历操作可以在非递归的情况下...
前序、中序、后序线索化二叉树
qq_45796208的博客
12-20 2904
为什么要线索化二叉树 先看一个问题 将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树. n+1=7 问题分析: 1、当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 } 2、但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上. 3、如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办? 4、解决方案-线索二叉树 线索化二叉树基本介绍 1、n个结点的二叉链表中含有n+1 ...
先序线索二叉树、中序线索二叉树和后序线索二叉树
01-01
对先序线索二叉树、中序线索二叉树和后序线索二叉树进行了 C 语言实现，主要包括线索二叉树的建立和遍历过程。
【数据结构】C语言实现二叉树的线索化——中序线索化、先序线索化、后序线索化
最新发布
蒙奇D索大的博客
03-18 864
【数据结构】第五章——树与二叉树——二叉树的线索化 详细介绍C语言实现二叉树的三种线索化——中序线索化、先序线索化、后序线索化
中序线索二叉树
YourClerk的博客
03-10 454
即增加Ltag和Rtag的方式来有效利用结点所占的空间，利用为NULL的指针域，能够存储其前驱结点和后继节点。 相比于对每个节点新增两个指针域，该方法更节约空间，因为int 占4字节，而一个指针占8字节，C99 还有_bool 一位即可存储，效果显著。 作用：寻找特定遍历序列二叉树的前驱和后驱，所以换前序和后序就不一样了，方法大同小异。像这样的中序，基本都是有框架了，看1.2.3部，中序都是在左与根中加操作。这里看起来2的结束在3后面（代码行），其实是2先结束。 注：供个人考研复习，写的不是很详细。
代码实现二叉树先序，中序，后序遍历，以及由先序和后序恢复二叉树
11-04
这种方法通常使用线索二叉树（也叫带附加信息的二叉树），因为在给定的两个序列中，后序遍历中的最后一个元素总是根节点，而这个信息可以帮助我们定位左右子树的位置。下面是基本步骤： - 遍历后序序列，找到最后一...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值