[数据结构] 严蔚敏版 线索二叉树C语言----惊为天人的按线索遍历算法

最新推荐文章于 2021-10-23 18:44:20 发布
最新推荐文章于 2021-10-23 18:44:20 发布
阅读量565 收藏 3
点赞数
分类专栏： c语言

自己完全写不来，只能品一品其中的韵味。

源码来自这里！http://www.cnblogs.com/kangjianwei101/p/5237880.html

#ifndef THREADBINARYTREE_H
#define THREADBINARYTREE_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Status.h"

//线索二叉树类型定义
typedef char TElemType_Thr;
typedef enum {Link, Thread} PointerTag;
typedef struct ThrBiNode
{
    TElemType_Thr data;
    struct ThrBiNode *lchild;
    struct ThrBiNode *rchild;
    struct ThrBiNode *parent;
    PointerTag LTag;
    PointerTag RTag;

} ThrBiNode, *ThrBiTree;

//函数列表
Status CreateBiTree_Thr (FILE *fp, ThrBiTree *T);

void InThreading_Thr (ThrBiTree p);
//中序线索化

Status CreateBiTreebyStr (ThrBiTree *T, char *ch, int *num);

Status InOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T);
//中序遍历并线索化

Status InOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr));

void PreThreading_Thr (ThrBiTree p);

Status PreOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T);

Status PreOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr));

void PostThreading_Thr (ThrBiTree p);

Status PostOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T);

Status PostOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr));

void ParentPointer_Thr (ThrBiTree Thrt);

ThrBiTree Post_NextPtr_Thr (ThrBiTree Thrt, ThrBiTree p);
//为后序遍历寻找结点后序提供帮助

void OutputbyStr_Tri (ThrBiTree T); //中序输出测试

Status InOrderTraverse (ThrBiTree Thrt,void (Visit)(TElemType_Thr));
#endif // THREADBINARYTREE_H

#ifndef THREADBINARYTREE_C
#define THREADBINARYTREE_C

#include "ThreadBinaryTree.h"

线索二叉树类型定义
//typedef char TElemType_Thr
//typedef enum {Link, Thread} PointerTag;
//typedef struct ThrBiNode
//{
//    TElemType_Thr data;
//    struct ThrBiNode *lchild;
//    struct ThrBiNode *rchild;
//    struct ThrBiNode *parent;
//    PointerTag LTag;
//    PointerTag RTag;
//
//} ThrBiNode, *ThrBiTree;

ThrBiTree pre;

//函数列表
Status CreateBiTree_Thr (FILE *fp, ThrBiTree *T)
{
    TElemType_Thr ch[15];
    fscanf(fp,"%s",ch);
    if (strcmpi(ch,"PreOrderTree")==0){
        fscanf(fp,"%s",ch);
        int num = 0;
//        printf("\nch = %s\n",ch);
        CreateBiTreebyStr (T,ch,&num);

//        OutputbyStr_Tri(*T);
        return OK;
    } else {

        return ERROR;
    }
}

void OutputbyStr_Tri (ThrBiTree T)
{
    if (T){
        printf("%c",T->data);
        OutputbyStr_Tri(T->lchild);
        OutputbyStr_Tri(T->rchild);
    } else {
        printf("^");
    }
}

Status CreateBiTreebyStr (ThrBiTree *T, char *ch, int *num)
{
    if (ch[*num]=='^'){
        *T = NULL;
        (*num)++;
    }
    else {
        *T = (ThrBiTree)malloc(sizeof(ThrBiNode));
        if(!*T)
            exit (OVERFLOW);
        (*T)->data = ch[*num];
        (*num)++;
        CreateBiTreebyStr(&(*T)->lchild,ch,num);
        if ((*T)->lchild)
            (*T)->LTag = Link;
        else
            (*T)->LTag = Thread;

        CreateBiTreebyStr(&(*T)->rchild,ch,num);
        if((*T)->rchild)
            (*T)->RTag = Link;
        else
            (*T)->RTag = Thread;
    }
    return OK;
}

void InThreading_Thr (ThrBiTree p)
{ //与中序遍历的结构类似
    if (p){
        InThreading_Thr(p->lchild);// 线索化左子树
        if (!p->lchild){ //为当前结点左子树建立前驱线索
            p->LTag = Thread;
            p->lchild = pre;
        }
        if (!pre->rchild){ //为上一个结点右子树建立后驱线索
            pre->RTag = Thread;
            pre->rchild = p;
        }
        pre = p; //pre挪到当前位置

        InThreading_Thr(p->rchild); //线索化右子树
    }
}
//中序线索化

Status InOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T)
{
    *Thrt = (ThrBiTree)malloc(sizeof(ThrBiNode));
    if (!*Thrt)
        exit(OVERFLOW);
    (*Thrt)->data = '\0';
    (*Thrt)->LTag = Link;
    (*Thrt)->RTag = Thread;
    (*Thrt)->rchild = *Thrt;

    if (!T)
        (*Thrt)->lchild = *Thrt;
    else {
            //第一个结点指向thrt，thrt后继指向最后一个结点，建立双向联系
        (*Thrt)->lchild = T;
        pre = *Thrt;
        InThreading_Thr(T);
        pre->RTag = Thread;
        pre->rchild = *Thrt;
        (*Thrt)->rchild = pre;
    }
    return OK;
}
//中序遍历并线索化

Status InOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr))
{
    ThrBiTree p = Thrt->lchild;

    while (p!=Thrt){
        while (p->LTag==Link)
            p = p->lchild;
        Visit(p->data);
        while (p->RTag==Thread && p->rchild!=Thrt){
            p = p->rchild;
            Visit(p->data);
        }
        p = p->rchild;
    }
    return OK;
}

Status InOrderTraverse (ThrBiTree Thrt,void (Visit)(TElemType_Thr))
{
    if (Thrt){
        if (Thrt->LTag==Link){
            InOrderTraverse(Thrt->lchild,Visit);
        }
        Visit(Thrt->data);
        if (Thrt->RTag==Link){
            InOrderTraverse(Thrt->rchild,Visit);
        }
    }
}

void PreThreading_Thr (ThrBiTree p)
{
    if (p){
        if (!pre->rchild){
            //为上一个结点的右子树建立后继线索
            pre->RTag = Thread;
            pre->rchild = p;
        }
        pre = p;
        PreThreading_Thr(p->lchild); //线索化左子树
        if (p->rchild && p->RTag==Link)
            PreThreading_Thr(p->rchild); //线索化右子树
    }
}

Status PreOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T)
{
    *Thrt = (ThrBiTree)malloc (sizeof(ThrBiNode));
    if (!*Thrt)
        exit (OVERFLOW);
    (*Thrt)->data = '\0';
    (*Thrt)->LTag = Link;
    (*Thrt)->RTag = Thread;
    (*Thrt)->rchild = NULL;
    if (!T)
        (*Thrt)->lchild = (*Thrt)->rchild = *Thrt;
    else {
        (*Thrt)->lchild = T;
        pre = *Thrt;

        PreThreading_Thr(T);

        pre->RTag = Thread;
        pre->rchild = *Thrt;
    }
    return OK;
}
Status PreOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr))
{
    ThrBiTree p = Thrt;
    while (p->rchild!=Thrt){
        while (p->lchild){
            p = p->lchild;
            Visit(p->data);
        }
        if (p->rchild!=Thrt){
            p = p->rchild;
            Visit(p->data);
        }
    }
    return OK;
}

void PostThreading_Thr (ThrBiTree p)
{
    if (p){
        if (!p->rchild){
            //为当前结点右子树建立后继线索
            p->RTag = Thread;
            p->rchild = pre;
        }
        pre = p; //pre在正常顺序中为后一个结点
        if (p->RTag!=Thread)
            PostThreading_Thr(p->rchild); //线索化右子树

        PostThreading_Thr(p->lchild); //线索化左子树
    }
}

Status PostOrderThreading_Thr (ThrBiTree *Thrt, ThrBiTree T)
{
    *Thrt = (ThrBiTree)malloc(sizeof(ThrBiNode));
    if (!*Thrt)
        exit (OVERFLOW);
    (*Thrt)->data = '\0';
    (*Thrt)->LTag = Link;
    (*Thrt)->RTag = Thread;
    (*Thrt)->rchild = *Thrt;

    if (!T)
        (*Thrt)->lchild = *Thrt;
    else {
        (*Thrt)->lchild = T;
        pre = *Thrt;
        PostThreading_Thr(T);
        (*Thrt)->rchild = T; //头结点回指
    }
    return OK;
}

Status PostOrderTraversebyThread (ThrBiTree Thrt,void (Visit)(TElemType_Thr))
{
    ThrBiTree p = Thrt->lchild;
    if(p!=Thrt){
        while(1){ //寻找遍历起点
            while (p->lchild)
                p = p->lchild;
            if (p->rchild && p->RTag!=Thread)
                p = p->rchild;
            else
                break;
        }
        while (p){
            Visit(p->data);
            p = Post_NextPtr_Thr(Thrt,p);
        }
    }
    return OK;
}

void ParentPointer_Thr (ThrBiTree T)
{
    ThrBiTree node[100];
    int i,j;
    i=j=0;
    if (T)
        node[j++] = T;
    node[i]->parent = NULL;
    while (i<j){
        if (node[i]->lchild){
            node[j++] = node[i]->lchild;
            node[i]->lchild->parent = node[i];
        }
        if (node[i]->rchild){
            node[j++] = node[i]->rchild;
            node[i]->rchild->parent = node[i];
        }
        i++;
    }
}

ThrBiTree Post_NextPtr_Thr (ThrBiTree Thrt, ThrBiTree p)
{
    //寻找p的后继
    if (p==Thrt->lchild) //根节点是最后一个结点
        return NULL;
    else {
        if (p->RTag==Thread)
            return p->rchild; //右孩子为线索
        else {
            if (p==p->parent->rchild) //当前结点是左孩子
                return p->parent;
            else{
                if (p->parent->RTag!=Link)
                    p = p->parent; //双亲结点没有右孩子
                else {
                    p = p->parent->rchild;
                    while (1){ //寻找右兄弟遍历起点
                        while (p->lchild)
                            p = p->lchild;
                        if (p->rchild && p->RTag!=Thread)
                            p = p->rchild;
                        else
                            break;
                    }
                }
                return p;
            }
        }
    }

}//为后序遍历寻找结点后序提供帮助

#endif // THREADBINARYTREE_C

#include <stdio.h>
#include <stdlib.h>

#include "ThreadBinaryTree.h"

void PrintElem (TElemType_Thr e);

int main(int argc, char **argv)
{
    ThrBiTree Thrt1,Thrt2,Thrt3,T1,T2,T3;
    int mark;

    printf("按先序序列创建二叉树\n");
    FILE *fp = fopen("TestData_T.txt","r");
    CreateBiTree_Thr(fp,&T1);
    fseek(fp,0,SEEK_SET);
    CreateBiTree_Thr(fp,&T2);
    fseek(fp,0,SEEK_SET);
    CreateBiTree_Thr(fp,&T3);
    fclose(fp);
    printf("\n");
//    OutputbyStr_Tri(T1);
//    OutputbyStr_Tri(T2);
    printf("测试先序后继线索二叉树\n");
    printf("将T1先序后继线索化为Thr1\n");
    PreOrderThreading_Thr(&Thrt1,T1);
    printf("\n");
    printf("先序遍历Thr1 = ");
    PreOrderTraversebyThread(Thrt1,PrintElem);


    printf("\n将T2中序全线索化为Thrt2\n");
    InOrderThreading_Thr(&Thrt2,T2);
    printf("中序遍历Thrt2 = ");
    InOrderTraversebyThread(Thrt2,PrintElem);
//    printf("\nOld-School Traverse = ");
//    InOrderTraverse(Thrt2->lchild,PrintElem);
//    printf("\n,Thrt2 data = %c",Thrt2->data);
    printf("\n");

    printf("为T3各结点寻找双亲结点\n");
    ParentPointer_Thr(T3);
    printf("\n");

    printf("将T3后序后继线索化为Thrt3\n");
    PostOrderThreading_Thr(&Thrt3,T3);
    printf("\n");

    printf("后序遍历线索化的Thrt3\n");
    PostOrderTraversebyThread(Thrt3,PrintElem);
    printf("\n");

    return 0;
}

void PrintElem (TElemType_Thr e)
{
    printf("%c",e);
}

txt: PreOrderTree ABDG^^^EH^^I^^CF^J^^^

as12cs
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之---C语言实现线索二叉树
杨鑫newlife的专栏
06-26 2359
数据结构之---C语言实现线索二叉树
数据结构_线索二叉树(C语言)
小黯
08-09 936
线索二叉树 1. 结构解析 线索二叉树，是一种对链式结构的一般二叉树进行线索的二叉树，其线索过程其实就是对一般二叉树空指针的修改； 例如我们按中序顺序，使左空指针指向前驱结点(上一个结点)，右空指针指向后继结点(下一个结点)，最后所形成的二叉树也就是线索二叉树。 结构如图 Lchild和Rchild分别表示左右指针域，LTag和RTag分别标志其左右指针是否为空。 中序线索二叉树例图 2. 源代码: #include<stdio.h> #include<stdlib.h>
C语言线索二叉树的实现
ZGUIZ的博客
01-19 2463
线索二叉树的主要操作，包含：以p为根节点的子树中序线索化，带头结点的二叉树中序线索化和遍历线索二叉树这几个函数。
数据结构--线索二叉树--C语言
和BUG做朋友的zhi的博客
03-30 224
线索二叉树的概念和存储结构 ①在有 n 个结点的二叉树中必定存在 n+1 个空链域（造成空间浪费）。 ②把这些空链域，建立相应结点的前驱结点信息和后继结点信息。 规定：当某结点的左指针为空时，令该指针指向中序遍历二叉树是得到的该结点的前驱结点。当某结点的右指针为空时，令该指针指向中序遍历二叉树是得到的该结点的后继结点。 ③为了区别是左右孩子还是前驱后继， 我们在结点中添加两个线索 typede...
数据结构之线索二叉树-C语言实现.pdf
最新发布
01-15
总的来说，线索二叉树是一种优化二叉树遍历的数据结构，通过在二叉链表中添加线索，可以避免在遍历时反复查找前驱和后继结点，提高了遍历效率。在C语言中实现线索二叉树需要理解二叉树的结构，并正确处理各种插入和...
C语言数据结构之线索二叉树及其遍历
12-31
C语言数据结构之线索二叉树及其遍历 遍历二叉树就是以一定的规则将二叉树中的节点排列成一个线性序列，从而得到二叉树节点的各种遍历序列，其实质是：对一个非线性的结构进行线性化。使得在这个访问序列中每一个节点...
数据结构--清华严蔚敏版 --二叉树的遍历--案例实现
05-22
二叉树是计算机科学中一种重要的数据结构，它在很多算法和问题解决中都有广泛应用，尤其是在数据存储和检索领域。二叉树的概念源自于它的基本结构：每个节点最多有两个子节点，通常分为左子节点和右子节点。这种特殊...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
根据给定文件的信息，我们可以详细地探讨一下关于二叉树的遍历算法这一主题，包括实验的目的、数据结构的设计、算法的设计以及输入/输出的设计等内容。 ### 实验目的 本次实验的主要目的是让学生深入理解并掌握...
C语言实现二叉树线索化
12-11
通过c语言实现二叉树的线索化，其中分四个子函数。
数据结构之线索二叉树（C语言实现）
DataH
04-03 1770
/* ******************************************************************************** * 数据结构 * * * * 作者: zhi-...
数据结构之线索二叉树(整理严蔚敏数据结构)
EditGP的专栏
10-12 830
#include using namespace std; typedef char ElemType; typedef enum { Link, Thread }PointType; typedef struct BThrNode { ElemType data; struct BThrNode *pLchild, *pRchild; PointType LTag, RTag; }BThr
【数据结构】线索二叉树_ThreadBinaryTree
博客
11-14 7959
#include "string.h" #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE
线索二叉树—C语言实现
qq_38236355的博客
09-19 491
线索二叉树的定义如下： https://www.jianshu.com/p/3965a6e424f5 程序实现： //线索二叉树 #define _CRT_SECURE_NO_WARNINGS #include <stdlib.h> #include <stdio.h> typedef char ElemType; typedef struct BITNODE //二叉树...
C语言实现线索二叉树
海马有力量的博客
10-23 706
学数据结构的时候没有学线索二叉树，现在考研需要，补上了。 线索二叉树中给每个节点加上标记，使叶节点的空的数据域填上前驱或者后继，使得线索二叉树能快速的找到前驱后继。 中序线索二叉树 线索化时如节点左子树为空，则添加前驱；设置全局变量pre，保存上一个访问的节点，访问下一个节点时，如果pre右子树为空，则pre的后继连上此节点。 #include<stdio.h> #include<stdlib.h> #define N 100 typedef int ElemType; type
线索二叉树的实现（C语言）
Lucky Home
04-30 3248
线索二叉树的实现（C语言）线索二叉树操作线索二叉树的建立线索二叉树的线索化线索二叉树的遍历总体 明天就要五一去重庆了，今天在坚持一下把这篇博文写完，也能减轻不少玩的负罪感啦。 线索二叉树 鉴于普通二叉树使用过程中会出现空间的浪费，后人对在在二叉树的的基础上做了改进，利用它的空指针域存放在某种遍历次序下指向它的前驱结点，和后继结点的指针。这些指针称为线索，相应的二叉树就成了线索二叉树。 我们就充分利用二叉链表的空闲结点进行操作，使之充分利用。 也就是在定义结构时外加两个标志域，若结点有左子树，则Lchild指
c语言实现线索二叉树
qq_33373173的博客
08-03 369
代码 #include <stdio.h> #include <stdlib.h> #define CHILD 0 #define THREAD 1 typedef struct Node { //线索二叉树节点 int val; struct Node *left, *right; int ltag, rtag; //区分left,right是孩子还是线索指针 } Node; Node *initNode(int val) { Node *n =
线索二叉树(C语言简单实现)
DFGOMC的博客
11-11 609
线索二叉树 本文参考自《大话数据结构》 原理 ​ 对于一个有n个结点的二叉链表，每个结点有指向左右孩子的指针域，所以一共有2n个指针域。而n个结点的二叉树一共有n-1条分支数，也就是说，其实是存在2n-(n-1)=n+1个空指针域，这些空指针域不存储任何东西，白白浪费着内存的资源。 ​ 我们做遍历的时候，比如中序遍历，我们可以知道任意一个结点的前驱和后继是谁；但是在二叉链表中给你，我们只能知道每个结点指向其左右孩子结点的地址，而不知道某个结点的前驱和后继。 ​ 为了充分利用这些空地址，可以用来存放
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值