C 线索化二叉树的实现

• n个结点一定有n+1个指针域是空的
• 如果结点左指针为空则作为前驱指针
• 若右指针为空则作为后继指针
• 指向线索序列的前序后继指针即为线索
• 同时为了区分指针是作为线索指向前驱后继还是指向子树，我们约定设置一个标志位，若为0指向子树，为1作为线索
• 每个节点除原来的数据域以及左右子孩子节点指针外，还需要增加两个标志域

lchild	L.Tag	data	R.Tag	rchild

• 线索化遍历过程中为了方便索引，建立两个节点，pre指向当前节点的前驱节点，T指向当前节点（pre和T都在接下的函数中有真实声明）

中序遍历二叉树T，将其线索化，Thrt指向其头结点

void InOrderThreading(BiThrTree *Thrt, BiThrTree T) {
    (*Thrt) = (BiThrTree)malloc(sizeof(BiThrNode));
    (*Thrt)->LTag = Link;
    (*Thrt)->RTag = Thread;
    (*Thrt)->rchild = (*Thrt);
    if (!T)
        (*Thrt)->lchild = (*Thrt);
    else {
        (*Thrt)->lchild = T;
        pre = (*Thrt);
        InThreading(T);
        pre->rchild = (*Thrt);
        pre->RTag = Thread;
        (*Thrt) -> rchild = pre;
    }
}

无头结点的整棵树T的线索化，作为上一个函数的辅助函数

void InThreading(BiThrTree T) {
    if (T) {
        InThreading(T->lchild);
        if (!T->lchild) {
            T->LTag = Thread;
            T->lchild = pre;    
        }
        if (!pre->rchild) {
            pre->RTag = Thread;
            pre->rchild = T;
        }
        pre = T;
        InThreading(T->rchild);
    }
}

中序遍历二叉树的非递归算法，Visit为打印data函数，定义在main文件

当前节点指向根节点

void InOrderTraverse_Thr(BiThrTree T, void(*Visit)(Elem e)) {
    BiThrTree p = T->lchild;
    while (p != T) {
        while (p->LTag == Link) {
            p = p->lchild;
        }
        Visit(p->data);
        while (p->RTag == Thread && p->rchild != T) {
            p = p->rchild;
            Visit(p->data);
        }
        p = p->rchild;
    }
}

然后直接看源码

BiThrTree.h

#ifndef _BITHRTREE_H_
#define _BITHRTREE_H_
#include <stdbool.h>

typedef char Elem;

typedef enum{Link, Thread}PointerTag;    //Link = 0表示指向左右孩子指针；Thread = 1表示指向前驱或后继的线索

typedef struct BiThrNode
{
       Elem data;                                      //结点数据
       struct BiThrNode *lchild, *rchild;                //左右孩子指针
       PointerTag  LTag, RTag;                              //左右标志
}BiThrNode, *BiThrTree;

//extern BiThrTree pre;

void CreateBiThrTree(BiThrTree *T);

void DestroyBiThrTree(BiThrTree *T);

void InOrderThreading(BiThrTree *Thrt, BiThrTree T);

void InThreading(BiThrTree T);

void InOrderTraverse_Thr(BiThrTree T, void(*Visit)(Elem e));

#endif

BiThrTree.c

#include <stdio.h>
#include <stdlib.h>
#include "BiThrTree.h"
#include <string.h>
BiThrTree pre;  //定义一个指向当前节点的前一个节点的pre指针，这里设置为全局变量
void CreateBiThrTree(BiThrTree *T) {
    char c;
    scanf("%c", &c);    

    if (c == '*') {
        (*T) = NULL;
    }
    else {
        (*T) = (BiThrTree)malloc(sizeof(BiThrNode));
            //exit(-1);
        (*T)->data = c;
        (*T)->LTag = (*T)->RTag = Link;
        CreateBiThrTree(&((*T)->lchild));
        CreateBiThrTree(&((*T)->rchild));   
    }

}

void DestroyBiThrTree(BiThrTree *T) {
    if ((*T)) {
            DestroyBiThrTree(&((*T)->lchild));
            DestroyBiThrTree(&((*T)->rchild));
            //(*T)->data='*';
            free((*T));
            (*T) = NULL;
        }   
}
void InOrderThreading(BiThrTree *Thrt, BiThrTree T) {
    (*Thrt) = (BiThrTree)malloc(sizeof(BiThrNode));
    (*Thrt)->LTag = Link;
    (*Thrt)->RTag = Thread;
    (*Thrt)->rchild = (*Thrt);
    if (!T)
        (*Thrt)->lchild = (*Thrt);
    else {
        (*Thrt)->lchild = T;
        pre = (*Thrt);
        InThreading(T);
        pre->rchild = (*Thrt);
        pre->RTag = Thread;
        (*Thrt) -> rchild = pre;
    }
}

void InThreading(BiThrTree T) {
    if (T) {
        InThreading(T->lchild);
        if (!T->lchild) {
            T->LTag = Thread;
            T->lchild = pre;    
        }
        if (!pre->rchild) {
            pre->RTag = Thread;
            pre->rchild = T;
        }
        pre = T;
        InThreading(T->rchild);
    }
}

void InOrderTraverse_Thr(BiThrTree T, void(*Visit)(Elem e)) {
    BiThrTree p = T->lchild;
    while (p != T) {
        while (p->LTag == Link) {
            p = p->lchild;
        }
        Visit(p->data);
        while (p->RTag == Thread && p->rchild != T) {
            p = p->rchild;
            Visit(p->data);
        }
        p = p->rchild;
    }
}

main.c

#include <stdio.h>
#include "BiThrTree.h"
void Visit(Elem e);
void Visit(Elem e) {
    printf("%c\n",e);
}
int main () {
    BiThrTree T;
    BiThrTree Thrt;
    CreateBiThrTree(&T);
    InOrderThreading(&Thrt, T);
    InOrderTraverse_Thr(Thrt, Visit);

    return 0;
}