一定要学会二叉树!!
一定要学会二叉树!!
一定要学会二叉树!!
#include <stdio.h>
#include <stdlib.h>
/****************************树定义******************************/
typedef enum{
TREENODE = 0,
LINKLISTNODE
}PointType;
typedef struct _BTNode_
{
char data;
PointType lPointType;
PointType rPointType;
struct _BTNode_ *lChild;
struct _BTNode_ *rChild;
}BTNode, *BTree;
/*****************************栈定义*******************************/
typedef struct __STACK_NODE__
{
BTree TreeNodeData;
struct __STACK_NODE__ *next;
}SNode_T, *SNode_P;
typedef struct __STACK__
{
SNode_P top;
int Num;
}STACK_T, *STACK_P;
/***************************队列定义********************************/
typedef struct __QUEUE_NODE__
{
BTree TreeNodeData;
struct __QUEUE_NODE__ *next;
struct __QUEUE_NODE__ *pre;
}QNode_T, *QNode_P;
typedef struct __QUEUE__
{
QNode_P top;
QNode_P tail;
int Num;
}QUEUE_T, *QUEUE_P;
/********************************************************************/
//队列初始化
QUEUE_P QueueInit()
{
QUEUE_P queue = NULL;
queue = (QUEUE_P)malloc(sizeof(QUEUE_T));
queue->top = (QNode_P)malloc(sizeof(QNode_T));
queue->tail = (QNode_P)malloc(sizeof(QNode_T));
queue->Num = 0;
queue->top->pre = NULL;
queue->top->next = queue->tail;
queue->tail->pre = queue->top;
queue->tail->next = NULL;
queue->tail->TreeNodeData = NULL;
queue->top->TreeNodeData = NULL;
return queue;
}
//入队
void QueuePush(QUEUE_P queue, BTree pTreeNode)
{
QNode_P newQnode = NULL;
if ((!pTreeNode)||(!queue))
{
return;
}
newQnode = malloc(sizeof(QNode_T));
newQnode->next = queue->top->next;
queue->top->next = newQnode;
newQnode->pre = newQnode->next->pre;
newQnode->next->pre = newQnode;
newQnode->TreeNodeData = pTreeNode;
queue->Num++;
return;
}
//出队
BTree QueuePop(QUEUE_P queue)
{
QNode_P tempnode = NULL;
BTree PopTreeNode = NULL;
if (!queue)
{
return NULL;
}
if (queue->Num == 0)
{
return NULL;
}
tempnode = queue->tail->pre;
queue->tail->pre = queue->tail->pre->pre;
queue->tail->pre->next = queue->tail;
queue->Num--;
PopTreeNode = tempnode->TreeNodeData;
free(tempnode);
return PopTreeNode;
}
//栈初始化
STACK_P StackInit()
{
STACK_P stack = NULL;
stack = (STACK_P)malloc(sizeof(STACK_T));
stack->top = (SNode_P)malloc(sizeof(SNode_T));
stack->top->next = NULL;
stack->top->TreeNodeData = NULL;
stack->Num = 0;
return stack;
}
//入栈
void StackPush(STACK_P stack, BTree pTreeNode)
{
SNode_P newSnode = NULL;
if ((!pTreeNode)||(!stack))
{
return;
}
newSnode = malloc(sizeof(SNode_T));
newSnode->TreeNodeData = pTreeNode;
newSnode->next = stack->top->next;
stack->top->next = newSnode;
stack->Num++;
return;
}
//出栈
BTree StackPop(STACK_P stack)
{
SNode_P tempnode = NULL;
BTree PopTreeNode = NULL;
if (!stack)
{
return NULL;
}
if (stack->Num == 0)
{
return NULL;
}
tempnode = stack->top->next;
stack->top->next = tempnode->next;
stack->Num--;
PopTreeNode = tempnode->TreeNodeData;
free(tempnode);
return PopTreeNode;
}
//获取栈顶元素
BTree StackTop(STACK_P stack)
{
SNode_P tempnode = NULL;
BTree PopTreeNode = NULL;
if (!stack)
{
return NULL;
}
if (stack->Num == 0)
{
return NULL;
}
return stack->top->next->TreeNodeData;
}
//前序创建二叉树
BTree CreateBTree_Pre()
{
BTree bt = NULL;
char ch;
scanf("%c", &ch);
if (ch != '#')
{
bt = (BTree)malloc(sizeof(BTNode));
bt->data = ch;
bt->lChild = CreateBTree_Pre();
bt->rChild = CreateBTree_Pre();
}
return bt;
}
//获取二叉树的高度
int GetTreeHeight(BTree bt)
{
int lHeight = 0;
int rHeight = 0;
if (bt)
{
lHeight = GetTreeHeight(bt->lChild);
rHeight = GetTreeHeight(bt->rChild);
return (lHeight > rHeight ? lHeight : rHeight) + 1;
}
return 0;
}
//销毁二叉树-递归
void BTreeDestroy(BTree bt)
{
if (bt)
{
if (bt->lChild)
{
BTreeDestroy(bt->lChild);
}
if (bt->rChild)
{
BTreeDestroy(bt->rChild);
}
if ((bt->lChild == NULL)&&(bt->rChild == NULL))
{
free(bt);
bt = NULL;
return ;
}
}
return ;
}
//销毁二叉树-非递归
int BTreeDestroyNew(BTree bt)
{
int lHeight = 0;
int rHeight = 0;
if (bt)
{
lHeight = GetTreeHeight(bt->lChild);
rHeight = GetTreeHeight(bt->rChild);
return (lHeight > rHeight ? lHeight : rHeight) + 1;
}
return 0;
}
//层序递归遍历二叉树
void LayerOrderTraverse(BTree bt, int level)
{
if (bt == NULL)
{
return;
}
if (level == 1)
{
printf("%c->", bt->data);
return;
}
LayerOrderTraverse(bt->lChild, level-1);
LayerOrderTraverse(bt->rChild, level-1);
return;
}
//中序递归遍历二叉树
void MidOrderTraverse(BTree bt)
{
if (bt == NULL)
{
return;
}
MidOrderTraverse(bt->lChild);
printf("%c->", bt->data);
MidOrderTraverse(bt->rChild);
}
//后序递归遍历二叉树
void AfterOrderTraverse(BTree bt)
{
if (bt == NULL)
{
return;
}
AfterOrderTraverse(bt->lChild);
AfterOrderTraverse(bt->rChild);
printf("%c->", bt->data);
}
//前序递归遍历二叉树
void PreOrderTraverse(BTree bt)
{
if (bt == NULL)
{
return;
}
printf("%c->", bt->data);
PreOrderTraverse(bt->lChild);
PreOrderTraverse(bt->rChild);
}
//前序遍历-非递归
void PreOrderTraverseByStack(STACK_P stack, BTree bt)
{
BTree cur = NULL;
if ((bt == NULL)||(stack == NULL))
{
return;
}
cur = bt;
while(cur != NULL || stack->Num)
{
while(cur)
{
printf("%c->", cur->data);
StackPush(stack, cur);
cur = cur->lChild;
}
cur = StackPop(stack)->rChild;
}
}
//中序遍历-非递归
void MidOrderTraverseByStack(STACK_P stack, BTree bt)
{
BTree cur = NULL;
if ((bt == NULL)||(stack == NULL))
{
return;
}
cur = bt;
while(cur != NULL || stack->Num)
{
while(cur)
{
StackPush(stack, cur);
cur = cur->lChild;
}
cur = StackPop(stack);
printf("%c->", cur->data);
cur = cur->rChild;
}
}
//后序遍历-非递归
void AfterOrderTraverseByStack(STACK_P stack, BTree bt)
{
BTree cur = NULL;
BTree last = NULL;
BTree top = NULL;
if ((bt == NULL)||(stack == NULL))
{
return;
}
cur = bt;
while(cur != NULL || stack->Num)
{
while(cur)
{
StackPush(stack, cur);
cur = cur->lChild;
}
top = StackTop(stack);
if ((top->rChild == NULL)||(top->rChild == last))
{
StackPop(stack);
printf("%c->", top->data);
last = top;
}
else
{
cur = top->rChild;
}
}
}
//层序遍历-非递归
void LevelOrderTraverseByQueue(QUEUE_P queue, BTree bt)
{
BTree top = NULL;
BTree cur = NULL;
if ((bt == NULL)||(queue == NULL))
{
return;
}
cur = bt;
QueuePush(queue, cur);
while(queue->Num)
{
top = QueuePop(queue);
if (top->lChild)
{
QueuePush(queue, top->lChild);
}
if (top->rChild)
{
QueuePush(queue, top->rChild);
}
printf("%c->", top->data);
}
}
//二叉树线索化
//树结点的左空指针指向前驱,右空结点指向后继
void PreOrderLinkListBTreePrint(BTree bt)
{
BTree lastpos = NULL;//指向上一次访问过的结点
if (bt == NULL)
{
return;
}
if (!bt->lChild)
{
bt->lPointType = LINKLISTNODE;
bt->lChild = lastpos;//左空结点指向前驱
}
if (!lastpos->rChild)
{
lastpos->rPointType = LINKLISTNODE;
lastpos->rChild = bt;//右空结点指向后继
}
lastpos = bt;
PreOrderTraverse(bt->lChild);
PreOrderTraverse(bt->rChild);
}
//前序线索化二叉树&前序遍历&后序遍历
void PreOrderLinkListBTree(BTree bt)
{
BTree lastpos = NULL;//指向上一次访问过的结点
if (bt == NULL)
{
return;
}
if (!bt->lChild)
{
bt->lPointType = LINKLISTNODE;
bt->lChild = lastpos;//左空结点指向前驱
}
if (!lastpos->rChild)
{
lastpos->rPointType = LINKLISTNODE;
lastpos->rChild = bt;//右空结点指向后继
}
lastpos = bt;
PreOrderTraverse(bt->lChild);
PreOrderTraverse(bt->rChild);
}
//中序线索化二叉树&前序遍历&后序遍历
void MidOrderLinkListBTree(BTree bt)
{
BTree lastpos = NULL;//指向上一次访问过的结点
if (bt == NULL)
{
return;
}
MidOrderLinkListBTree(bt->lChild);
if (!bt->lChild)
{
bt->lPointType = LINKLISTNODE;
bt->lChild = lastpos;
}
if (!lastpos->rChild)
{
lastpos->rPointType = LINKLISTNODE;
lastpos->rChild = bt;
}
lastpos = bt;
MidOrderLinkListBTree(bt->rChild);
}
//后序线索化二叉树&前序遍历&后序遍历
void AfterOrderLinkListBTree(BTree bt)
{
BTree lastpos = NULL;//指向上一次访问过的结点
if (bt == NULL)
{
return;
}
MidOrderLinkListBTree(bt->lChild);
MidOrderLinkListBTree(bt->rChild);
if (!bt->lChild)
{
bt->lPointType = LINKLISTNODE;
bt->lChild = lastpos;
}
if (!lastpos->rChild)
{
lastpos->rPointType = LINKLISTNODE;
lastpos->rChild = bt;
}
lastpos = bt;
}
//层序线索化二叉树&前序遍历&后序遍历
void LevelOrderLinkListBTree()
{
return;
}
int main()
{
//AB#D##CE##F##
BTree bt;
STACK_P stack = NULL;
QUEUE_P queue = NULL;
int i = 0;
int Height = 0;
stack = StackInit();
queue = QueueInit();
bt = CreateBTree_Pre();
printf("\n前序递归遍历:");
PreOrderTraverse(bt); /* 前序递归遍历 */
printf("\n中序递归遍历:");
MidOrderTraverse(bt); /* 中序递归遍历 */
printf("\n后序递归遍历:");
AfterOrderTraverse(bt); /* 后序递归遍历 */
printf("\n层序递归遍历:");
Height = GetTreeHeight(bt);
for (i = 1; i <= Height; i++)/* 层序递归遍历 */
{
LayerOrderTraverse(bt, i);
}
printf("\n前序非递归遍历:");
PreOrderTraverseByStack(stack, bt);
printf("\n中序非递归遍历:");
MidOrderTraverseByStack(stack, bt);
printf("\n后序非递归遍历:");
AfterOrderTraverseByStack(stack, bt);
printf("\n层序非递归遍历:");
LevelOrderTraverseByQueue(queue, bt);
free(queue->top);
free(queue->tail);
free(queue);
free(stack->top);
free(stack);
BTreeDestroy(bt);
printf("\n\r");
return 0;
}