DS基础--先序遍历二叉树（递归、非递归、线索二叉树，C语言描述）

先序遍历二叉树的递归合非递归方式在我之前的博客中分享过了，博客加入了二叉树的线索化，构造先序线索二叉树的这么一种方式。关于中序线索二叉树的构建及其线索化方法在严蔚敏的书算法描述得很详尽了，后序线索二叉树的线索化过程，需要使用三叉链表的结构，这里只描述先序线索化方法，注释和相关描述比较详尽了，这些代码可直接上机调试Talking is cheap,just show code:

/*
 * The Ways of PreOrderTraverse Binary Tree.
 * Just Practice Building PreOrderThreading Binary Tree.
 * Understand the Thinking of Binary Tree Threading.
 *
 * In My View,Building "PreOrderThread Tree" Needs the Fllowing Steps:
 * 1.Create a Binary Tree
 * 2.Threading
 * 1) Create a "Head Node" of This Tree
 * 2) Traversing the Tree in "PreOrder Way"
 * -> Threading this Node.Just Threading The NULL Pointer(Building the Link Between "this(->lchild)" and "pre(->rchild)")
 * -> Threading(this->lchild)
 * -> Threading(this->rchild)
 * 3) Don't Forget Threading The Final Node (rchild = Thrt)
 * 3.Traversing(Dependence Its Traverseing Way)
 * 
 */
 
#include <stdio.h>
#include <stdlib.h>


#define OK 1
#define ERROR 0
#define OVERFLOW -1


#define STACK_MAXSIZE 16
#define STACK_INCREMENT 10


#define DEBUG 1


typedef enum PointerTag{
Link,
Thread
}PointerTag;


typedef int Status;
typedef char Elemtype;


typedef struct BinThrNode{
Elemtype data;
struct BinThrNode *lchild,*rchild;
PointerTag LTag,RTag;
}BinThrNode,*BinThrTree;


typedef struct{
BinThrTree *base,*top;
int length;
}SqStack;


static BinThrTree pre;


/* ----- Stack Operation ----- */
static Status InitStack(SqStack *Stack)
{
if(!(Stack->base = (BinThrTree *)malloc(STACK_MAXSIZE * sizeof(BinThrTree))))
exit(OVERFLOW);


Stack->top = Stack->base;
Stack->length = STACK_MAXSIZE;


return OK;
}


static Status DestoryStack(SqStack *Stack)
{
if(!Stack->base)
return ERROR;


free(Stack->base);
Stack->top = Stack->base = NULL;
Stack->length = 0;


return OK;
}


static Status Push(SqStack *Stack,BinThrTree e)
{
if(Stack->top - Stack->base >= Stack->length)
{
if(!(Stack->base = (BinThrTree *)realloc(Stack->base,(Stack->length + STACK_INCREMENT) * sizeof(BinThrTree))))
exit(OVERFLOW);


Stack->top = Stack->base + Stack->length;
Stack->length += STACK_INCREMENT;
}

*Stack->top++ = e;

return OK;
}


static Status Pop(SqStack *Stack,BinThrTree *e)
{
if(Stack->base == Stack->top)
return ERROR;

*e = *--Stack->top;
return OK;
}


static Status StackEmpty(SqStack *Stack)
{
return Stack->base == Stack->top;
}


/* ----- Create Binary Tree ----- */
static Status CreateBinTree(BinThrTree *T)
{
Elemtype ch;


ch = getchar();

if(' ' == ch)
*T = NULL;
else
{
if(!(*T = (BinThrTree)malloc(sizeof(BinThrNode))))
exit(OVERFLOW);

(*T)->data = ch;
CreateBinTree(&(*T)->lchild);
CreateBinTree(&(*T)->rchild);
}

return OK;
}


static Status PrintNode(Elemtype data)
{
printf("%c",data);
return OK;
}


/* PreOrderTraverse The Binary Tree in Recurse Way */
static Status PreOrderTraverse(BinThrTree T,Status (*visit)(Elemtype))
{
if(T)
{
visit(T->data);
PreOrderTraverse(T->lchild,visit);
PreOrderTraverse(T->rchild,visit);
}

return OK;
}


/* PreOrderTraverse The Binary Tree in No Recurse Way */
static Status _PreOrderTraverse(BinThrTree T,Status (*visit)(Elemtype))
{
BinThrTree p = T;
SqStack S;


InitStack(&S);
while(p || !StackEmpty(&S))
{
if(p)
{
if(!visit(p->data))
return ERROR;


Push(&S,p);
p = p->lchild;
}
else
{
Pop(&S,&p);
p = p->rchild;
}
}

DestoryStack(&S);
}


/* PreOrderTraverse The Binary Tree By Create PreOrderThread Binary Tree*/
static void PreThreading(BinThrTree 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
pre->RTag = Link;


pre = p;


if(Link == p->LTag)
PreThreading(p->lchild);

if(Link == p->RTag)
PreThreading(p->rchild);

}
}


static Status PreOrderThreading(BinThrTree *Thrt,BinThrTree T)
{
if(!(*Thrt = (BinThrTree)malloc(sizeof(BinThrNode))))
exit(OVERFLOW);


(*Thrt)->LTag = Thread;
(*Thrt)->RTag = Thread;
(*Thrt)->rchild = *Thrt;


if(!T)
(*Thrt)->lchild = *Thrt;
else
{
(*Thrt)->lchild = T;
pre = *Thrt;


PreThreading(T);


pre->RTag = Thread;
pre->rchild = *Thrt;
(*Thrt)->rchild = pre;
}
}


static Status PreOrderTraverse_Thr(BinThrTree Thrt,Status (*visit)(Elemtype))
{
BinThrTree p = Thrt->lchild;


while(p != Thrt)
{
if(!visit(p->data))
return ERROR;


while(Link == p->LTag)
{
p = p->lchild;

if(!visit(p->data))
return ERROR;
}

p = p->rchild;
}
}


#if DEBUG
/* Show The Binary Tree In "List" Way */
static Status ShowBinTree(BinThrTree T)
{
if(T)
{
PrintNode(T->data);


printf("(");
ShowBinTree(T->lchild);
printf(",");
ShowBinTree(T->rchild);
printf(")");
}
else
printf("NULL");

return OK;
}
#endif


int main(void)
{
BinThrTree Root,Head;


CreateBinTree(&Root);


#if DEBUG
ShowBinTree(Root);
printf("\n");
#endif


/* Result */
printf("Recurse Way:")
PreOrderTraverse(Root,PrintNode);
printf("\n");


printf("No Recurse Way:")
_PreOrderTraverse(Root,PrintNode);
printf("\n");


printf("PreOrderThreading Way:")
PreOrderThreading(&Head,Root);
PreOrderTraverse_Thr(Head,PrintNode);
printf("\n");

return 0;
}