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;
}