c语言二叉树遍历头文件,C语言二叉树遍历操作

#include

#include

#include

#define MAX_TREE_SIZE 80

typedef struct bit_tree_node

{

unsigned int num;

struct bit_tree_node *lchild,*rchild;

}tree_node,*bit_tree;

unsigned int create_tree(bit_tree *tree)//指针的指针

{

unsigned int num;

printf("please input:\n");

scanf("%d",&num);

if(num == 0)

{

return -1;

}

else

{

*tree =(bit_tree)malloc(sizeof(tree_node));

memset(*tree,0,sizeof(tree_node));

(*tree)->num = num;

printf("please input %d's left child:",(*tree)->num);

create_tree(&((*tree)->lchild));

printf("please input %d's right child:",(*tree)->num);

create_tree(&((*tree)->rchild));

}

return 0;

}

void pre_order(bit_tree tree)//前序遍历

{

if(tree != NULL)

{

printf("%d,",tree->num);

pre_order(tree->lchild);

pre_order(tree->rchild);

}

}

void in_order(bit_tree tree)//中序遍历

{

if(tree != NULL)

{

pre_order(tree->lchild);

printf("%d,",tree->num);

pre_order(tree->rchild);

}

}

void post_order(bit_tree tree)//后序遍历

{

if(tree != NULL)

{

pre_order(tree->lchild);

pre_order(tree->rchild);

printf("%d,",tree->num);

}

}

void print_tree(bit_tree tree,int layer)

{

if(tree == NULL)

{

return;

}

print_tree(tree->rchild,layer+1);

for(int i=0;i

{

printf("----");

}

printf("%d\n",tree->num);

print_tree(tree->lchild,layer+1);

}

void pre_tree(bit_tree tree)//前序非递归遍历

{

bit_tree stack[MAX_TREE_SIZE];

int top = 0;

while(tree != NULL||top!= 0)

{

if(tree != NULL)

{

printf("%d\n",tree->num);

top++;

stack[top] = tree;

tree = tree->lchild;

}

else

{

tree = stack[top];

top--;

tree = tree->rchild;

}

}

}

void in_tree(bit_tree tree)//中序非递归遍历

{

bit_tree stack[MAX_TREE_SIZE];

int top = 0;

while(tree != NULL||top!= 0)

{

if(tree != NULL)

{

top++;

stack[top] = tree;

tree = tree->lchild;

}

else

{

tree = stack[top];

top--;

printf("%d\n",tree->num);

tree = tree->rchild;

}

}

}

void post_tree1(bit_tree tree)//后序非递归遍历1

{

bit_tree stack[MAX_TREE_SIZE];

int top = 0;

bit_tree p = tree;

bit_tree q = NULL;

while(p != NULL || top != 0)

{

while(p != NULL)

{

top++;

stack[top] = p;

p = p->lchild;

}

if(top>0)

{

p = stack[top];

if(p->rchild == NULL || p->rchild == q)

{

top--;

printf("%d\n",p->num);

q = p;

p= NULL;

}

else

{

p = p->rchild;

}

}

}

}

void post_tree2(bit_tree tree)//后序非递归遍历2

{

bit_tree stack[MAX_TREE_SIZE];

int top = 0;

bit_tree save[MAX_TREE_SIZE];

int save_top = 0;

while(tree != NULL||top!= 0)

{

if(tree != NULL)

{

save_top++;

save[save_top] = tree;

top++;

stack[top] = tree;

tree = tree->rchild;

}

else

{

tree = stack[top];

top--;

tree = tree->lchild;

}

}

while(save_top !=0)

{

printf("%d\n",save[save_top]->num);

save_top--;

}

}

void layer_tree(bit_tree tree)//层次遍历遍历

{

bit_tree queue[MAX_TREE_SIZE];

int head = 0;

int tail = 0;

bit_tree tree_node;

if(tree != NULL)

{

queue[tail] = tree;

tail++;

}

while(head != tail)

{

tree_node = queue[head];

head++;

printf("%d\n",tree_node->num);

if(tree_node->lchild != NULL)

{

queue[tail] = tree_node->lchild;

tail++;

}

if(tree_node->rchild != NULL)

{

queue[tail] = tree_node->rchild;

tail++;

}

}

}

void main()

{

bit_tree tree;

create_tree(&tree);

int choice = 0;

while(choice != -1)

{

scanf("%d",&choice);

switch(choice)

{

case 1:

print_tree(tree,1);

break;

case 2:

pre_order(tree);

break;

case 3:

pre_tree(tree);

break;

case 4:

post_tree1(tree);

break;

case 5:

layer_tree(tree);

break;

case 7:

in_tree(tree);

break;

case 8:

post_tree2(tree);

break;

default:

break;

}

}

}