二叉树的线索化

二叉树的线索化

头文件

#include"stdio.h"

typedef char DataType;

typedef enum{ LINK, THREAD }PointFlag;

typedef struct BinTreeNode

{

struct BinTreeNode* _pLeft;

struct BinTreeNode* _pRight;

struct BinTreeNode* _pParent;

DataType _data;

PointFlag _leftThread;

PointFlag _rightThread;

 

}Node, *PNode;

void InitBinTree(PNode pRoot);

PNode BuyNode(DataType data);

void _CreateBinTree(PNode* pRoot, DataType array[], int size, int* index, DataType invalid);

void CreateBinTree(PNode* pRoot, DataType array[], int size, DataType invalid);

void _PreOrderThd(PNode pRoot, PNode* prev);//非递归前序线索化

void PreOrderThd(PNode pRoot);//递归前序线索化

 

 

void _InOrderThd(PNode pRoot, PNode* prev);//非递归中序线索化

void InOrderThd(PNode pRoot);//递归中序线索化

void _PostOrderThd(PNode pRoot, PNode* prev);//非递归后序线索化

void PostOrderThd(PNode pRoot);//递归后续线索化

void PreOrderD(PNode pRoot);//前序

void InOrderD(PNode pRoot);//中序

void postOrderD(PNode pRoot);//后序

 

函数部分

#include"Treenode.h"

void InitBinTree(PNode pRoot)

{

pRoot = 0;

}

void CreateBinTree(PNode* pRoot, DataType* array, int size, DataType invalid)

{

int index = 0;

_CreateBinTree(&pRoot,  array, size, &index, '#');

}

void _CreateBinTree(PNode* pRoot, DataType* array, int size, int* index, DataType invalid)

{

if (invalid != array[*index])

{

 

PNode pRoot = BuyNode(array[*index]);

        PNode pRoot-> _pLeft = _CreateBinTree(&pRoot, array, size, ++(*index), '#');

PNode pRoot->_pRight = _CreateBinTree(&pRoot, array, size, ++(*index), '#');

}

}

PNode BuyNode(DataType data)

{

PNode pNewNode = (PNode)malloc(sizeof(Node));

assert(pNewNode);

pNewNode->_pLeft = NULL;

pNewNode->_pRight = NULL;

pNewNode->_pParent = NULL;

pNewNode->_data = data;

pNewNode->_leftThread = LINK;

pNewNode->_rightThread = LINK;

 

return pNewNode;

}

void InOrderThd(PNode pRoot)//递归中序线索化

{

PNode prev = NULL;

_InOrderThd(pRoot, &prev);

}

void _PreOrderThd(PNode pRoot, PNode* prev)//非递归前序线索化

{

PNode prev = NULL;

if (pRoot)

 

{

if (NULL == pRoot->_pLeft)//线索化左子树

{

pRoot->_pLeft = prev;//标记

pRoot->_leftThread = THREAD;//已经被线索化

}

 

if (*prev&& NULL == (*prev)->_pRight)//线索化右子树

{

(*prev)->_pRight = prev;

(*prev)->_rightThread = THREAD;

}

PNode *prev = pRoot;

 

if (pRoot->_leftThread == LINK)//可能有左子树

{

_PreOrderThd(pRoot->_pLeft, &prev);//对其左子树进行线索化

}

if (pRoot->_rightThread == LINK)//可能有右子树

{

_PreOrderThd(pRoot->_pRight, &prev);

 

}

}

}

void PreOrderThd(PNode pRoot)//递归前序线索化

{

PNode prev = NULL;

_PreOrderThd(pRoot, &prev);

}

void _InOrderThd(PNode pRoot, PNode* prev) // 非递归中序线索化

{

if (pRoot)

{

 

_InOrderThd(pRoot, &prev);//找到最左端的结点D

 

if (pRoot->_pLeft == NULL)

{

pRoot->_pLeft = prev;

pRoot->_leftThread = THREAD;

}

PNode *prev = pRoot;

 

if (pRoot->_pRight == NULL)

{

pRoot->_pRight = *prev;//D的后继指向B

pRoot->_leftThread = THREAD;

}

}

}

void InOrderThd(PNode pRoot)//递归中序线索化

{

PNode prev = NULL;

_InOrderThd(pRoot, &prev);

}

 

void _PostOrderThd(PNode pRoot, PNode* prev)//非递归后序线索化

{

PNode prev = NULL;

if (pRoot)//遍历左子树,找到最左端的点D

 

{

_PostOrderThd(pRoot->_pLeft, &prev);

 

if (NULL == pRoot->_pLeft)

{

pRoot->_pLeft = *prev;

pRoot->_leftThread = THREAD;

}

*prev = pRoot;

if (pRoot->_pRight == NULL)

{

pRoot->_pRight = *prev;

pRoot->_rightThread = THREAD;

}

}

    

}

void PostOrderThd(PNode pRoot)//递归后序线索化

{

PNode prev = NULL;

_PostOrderThd(pRoot, &prev);

}

void PreOrderD(PNode pRoot)//前序递归

{

if (pRoot)

{

printf("%c ", pRoot->_data);

PreOrderD(pRoot->_pLeft);

PreOrderD(pRoot->_pRight);

}

}

 

void PreOrder(PNode pRoot)//非递归前序,中左右

{

PNode pcur = pRoot;

while (pcur)

{

while (pcur->_leftThread == LINK)//有左子树

{

prinf("d%", pcur->_data);//遍历当前节点

pcur = pcur->_pLeft;

 

}//遍历A与B

printf("d%", pcur->_data);//遍历没有左子树的结点

while (pcur->_rightThread == THREAD)//没有右子树

{

pcur = pcur->_pRight;

//后继

printf("d%", pcur->_data);

 

}

if (pcur->_leftThread == LINK)//有左子树

 

pcur = pcur->_pLeft;//pcur成为e

else

pcur = pcur->_pRight;

}

}

void InOrderD(PNode pRoot)//递归中序

{

if (pRoot)

{

InOrderD(pRoot->_pLeft);

printf("%c ", pRoot->_data);

InOrderD(pRoot->_pRight);

}

void InOrderD(PNode pRoot)//非递归中序，中左右

{

PNode pcur = pRoot;

while (pcur)

{

while (pcur->_leftThread == LINK)//有左子树

{

 

pcur = pcur->_pLeft;

 

}

printf("d%", pcur->_data);//遍历当前节点

while (pcur->_rightThread == THREAD)//没有右子树

{

pcur = pcur->_pRight;

//后继

printf("d%", pcur->_data);

 

}

pcur = pcur->_pRight;

}

}

 

void postOrderD(PNode pRoot)//后序,左右中

{

PNode pcur = pRoot;

PNode prev = NULL;

while (pcur)

{

while (pcur->_leftThread == LINK)//有左子树

{

 

pcur = pcur->_pLeft;

 

}

while (pcur->_rightThread == THREAD)//没有右子树

{

printf("d%", pcur->_data);

prev = pcur;

pcur = pcur->_pRight;

 

}

if (pcur == pRoot&&NULL == pRoot->_pRight || prev == pRoot->_pRight)

{

printf("d%", pcur->_data);

return;

}

while (pcur->_pRight == LINK&&pcur)

{

printf("d%", pcur->_data);

prev = pcur;

 

}

pcur = pcur->_pParent;

}

}