二叉树的遍历
递归先序中序后序非递归先序中序后序
调试二叉树各种遍历算法,第七章,实验题2(JXUST)
#include <iostream>
#include <stdio.h>
using namespace std;
/*
* 二叉树的定义和各种运算部分
*/
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node* lchild;
struct node* rchild;
}BTNode;
void CreateBTree(BTNode*& b, char* str) //创造二叉树
{
BTNode* St[MaxSize], * p;
int top = -1, k, j = 0;
char ch;
b = NULL;
ch = str[j];
while (ch != '\0')
{
switch (ch)
{
case '(':top++; St[top] = p; k = 1; break;
case ')':top--; break;
case ',':k = 2; break;
default:
p = (BTNode*)malloc(sizeof(BTNode));
p->data = ch;
p->lchild = p->rchild = NULL;
if (b == NULL)
b = p;
else
{
switch (k)
{
case 1:St[top]->lchild = p; break;
case 2:St[top]->rchild = p; break;
}
}
}
j++;
ch = str[j];
}
}
void DestroyBtree(BTNode*& b) //销毁二叉树
{
if (b != NULL)
{
DestroyBtree(b->lchild);
DestroyBtree(b->rchild);
free(b);
}
}
BTNode* FindNode(BTNode* b, ElemType x)
{
BTNode* p;
if(b == NULL)
{
return NULL;
}
else if(b->data == x)
{
return b;
}
else
{
p = FindNode(b->lchild, x);
if(p != NULL)
{
return p;
}
else
{
return FindNode(b->rchild, x);
}
}
}
BTNode* LchildNode(BTNode* p) //返回左子树
{
return p->lchild;
}
BTNode* RchildNode(BTNode* p) //返回右子树
{
return p->rchild;
}
int BTHeight(BTNode* b) //求二叉树的高度
{
int lchildh, rchildh;
if(b == NULL) return 0;
else
{
lchildh = BTHeight(b->lchild);
rchildh = BTHeight(b->rchild);
return (lchildh > rchildh) ? (lchildh + 1) : (rchildh + 1);
}
}
void DispBTree(BTNode* b) //输出二叉树
{
if(b != NULL)
{
cout << b->data;
if (b->lchild != NULL || b->rchild != NULL)
{
cout << "(";
DispBTree(b->lchild);
if (b->rchild != NULL) cout << ",";
DispBTree(b->rchild);
cout << ")";
}
}
}
/*
* 队列定义和各种算法部分
*/
typedef struct {
BTNode* data[MaxSize];
int front, rear;
}SqQueue;
void InitQueue(SqQueue*& q)
{
q = (SqQueue*)malloc(sizeof(SqQueue));
q->front = q->rear = 0;
}
void DestroyQueue(SqQueue*& q)
{
free(q);
}
bool QueueEmpty(SqQueue* q)
{
return (q->front == q->rear);
}
bool enQueue(SqQueue*& q, BTNode* e)
{
if((q->rear + 1) % MaxSize == q->front)
{
return false;
}
q->rear = (q->rear + 1) % MaxSize;
q->data[q->rear] = e;
return true;
}
bool deQueue(SqQueue*& q, BTNode*& e)
{
if(q->front == q->rear)
{
return false;
}
q->front = (q->front + 1) % MaxSize;
e = q->data[q->front];
return true;
}
/*
* 栈定义部分
*/
typedef struct
{
BTNode* data[MaxSize];
int top;
}SqStack;
void InitStack(SqStack*& s)
{
s = (SqStack*)malloc(sizeof(SqStack));
s->top = -1;
}
void DestroyStack(SqStack*& s)
{
free(s);
}
bool StackEmpty(SqStack* s)
{
return (s->top == -1);
}
bool Push(SqStack*& s, BTNode* e)
{
if(s->top == MaxSize - 1) {
return false;
}
s->top++;
s->data[s->top] = e;
return true;
}
bool Pop(SqStack*& s, BTNode*& e)
{
if(s->top == -1)
return false;
e = s->data[s->top];
s->top--;
return true;
}
bool GetTop(SqStack* s, BTNode*& e)
{
if(s->top == -1)
return false;
e = s->data[s->top];
return true;
}
/*
* 2.调试二叉树各种遍历算法,第七章,实验题2
*/
#include <iostream>
#include <stdio.h>
using namespace std;
#include "btreeadd.cpp"
/*
* 遍历
*/
void PreOrder(BTNode* b) //递归先序遍历
{
if (b != NULL)
{
printf("%c ",b->data);
PreOrder(b->lchild);
PreOrder(b->rchild);
}
}
void PreOrder1(BTNode* b) //非递归先序遍历
{
BTNode* p;
SqStack* st;
InitStack(st);
if (b != NULL)
{
Push(st, b);
while (!StackEmpty(st))
{
Pop(st, p);
printf("%c ",p->data);
if (p->rchild != NULL)
{
Push(st, p->rchild);
}
if (p->lchild != NULL)
{
Push(st, p->lchild);
}
}
cout << endl;
}
DestroyStack(st);
}
void InOrder(BTNode* b) //递归中序遍历
{
if (b != NULL)
{
InOrder(b->lchild);
printf("%c ",b->data);
InOrder(b->rchild);
}
}
void InOrder1(BTNode* b) //非递归中序遍历
{
BTNode* p;
SqStack* st;
InitStack(st);
p = b;
while (!StackEmpty(st) || p != NULL)
{
while (p != NULL)
{
Push(st, p);
p = p->lchild;
}
if (!StackEmpty(st))
{
Pop(st, p);
printf("%c ",p->data);
p = p->rchild;
}
}
cout << endl;
DestroyStack(st);
}
void PostOrder(BTNode* b) //递归后序遍历
{
if (b != NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
printf("%c ",b->data);
}
}
void PostOrder1(BTNode* b) //非递归后序遍历
{
BTNode* p, * r;
bool flag;
SqStack* st;
InitStack(st);
p = b;
do {
while (p != NULL)
{
Push(st, p);
p = p->lchild;
}
r = NULL;
flag = true;
while (!StackEmpty(st) && flag)
{
GetTop(st, p);
if (p->rchild == r)
{
printf("%c ",p->data);
Pop(st, p);
r = p;
}
else
{
p = p->rchild;
flag = false;
}
}
} while (!StackEmpty(st));
printf("\n");
DestroyStack(st);
}
/*
* 层次遍历
*/
void LevelOrder(BTNode* b)
{
BTNode* p;
SqQueue* qu;
InitQueue(qu);
if (b != nullptr)
{
enQueue(qu, b);
while (!QueueEmpty(qu))
{
deQueue(qu, p);
printf("%c ",p->data);
if (p->lchild != NULL)
enQueue(qu, p->lchild);
if (p->rchild != NULL)
enQueue(qu, p->rchild);
}
}
}
int main(void)
{
BTNode* b;
char str[] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
CreateBTree(b, str);
printf("初始化二叉树为:\n");DispBTree(b);
printf("\n");
printf("递归先序遍历:\t");PreOrder(b);
printf("\n");
printf("非递归先序遍历:\t");PreOrder1(b);
printf("递归中序遍历:\t");InOrder(b);
printf("\n");
printf("非递归中序遍历:\t");InOrder1(b);
printf("递归后序遍历:\t");PostOrder(b);
printf("\n");
printf("非递归后序遍历:\t");PostOrder1(b);
printf("层次遍历:\t");LevelOrder(b);
printf("\n");
return 0;
}