二叉树的遍历（C语言）（数据结构）

二叉树的基本操作

 按前辈们的说法，在嵌入式的开发中并不用得到二叉树。在次就仅仅对二叉树的基本操作作简单介绍。

二叉树性质 

（1）第 i 层最多有 2^(i-1) 个节点。

（2）深度为 k 的二叉树至多有 2^k - 1 个节点。

（3）若一个二叉树终端节点个数为 n，度为 2 的节点个数为 m，则有 n = m+1。

（4）有 n 个节点的完全二叉树深度为 log2(n) + 1。

（5）如果对一颗有 n 个节点的二叉树的节点按层序编号，对任一节点：

         * 如果 i = 1， 则节点 i 是二叉树的根，无双亲。

           如果 i > 1， 则某节点的双亲是 i / 2

         * 如果 2i > n，则节点 i 无左子树，否则左子树是 2i 。

         * 如果 2i+1 > n，则节点 i 无右子树，否则右子树是 2i 。

二叉树遍历

二叉树有三种遍历方式，分别为先序遍历、中序遍历、后序遍历

先序遍历：

        （1）先访问根节点。

        （2）再访问左子树。

        （3）最后访问右子树。

中序遍历：

        （1）先访问左子树。

        （2）再访问根节点。

        （3）最后访问右子树。

后序遍历：

        （1）先访问左子树。

        （2）再访问右子树。

        （3）最后访问根节点。

比如如下的二叉树

先序遍历结果为    ABCDEFG

中序遍历结果为    CBEDAFG

后序遍历结果为    CEDBGFA

代码展示

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
//二叉树节点信息
struct binarytreenode
{
	int  data;
	struct binarytreenode *lchild;//左子树
	struct binarytreenode *rchild;//右子树
};
typedef struct binarytreenode BiTNode;
 
void print( int e)
{
	printf(" %2d", e);
}
 
 
//二叉树创建
BiTNode *CreatTree( int *a)
{
	int i;
	BiTNode *pNode[11] = {0};
 
	for ( i = 0; i < 10; i++)
	{
		pNode[i] = (BiTNode *) malloc(sizeof(BiTNode));
 
		if ( NULL == pNode[i])
		{
			printf("malloc error!\n");
			exit(1);
		}
 
		pNode[i]->lchild = NULL;
 
		pNode[i]->rchild = NULL;
 
		pNode[i]->data = a[i];
	}
 
	for ( i = 0; i < 10/2; i++)
	{
		pNode[i]->lchild = pNode[ 2 * (i + 1) - 1];
 
		pNode[i]->rchild = pNode[ 2 * (i + 1) + 1 - 1];
	}
 
	return pNode[0];
}
 
//先序遍历
int  PreOrderTraverse( BiTNode *root, void (*visit)(int) )
{
	if ( NULL == root)
	{
		return 1;
	}
 
	(*visit)(root->data);
 
	if ( PreOrderTraverse(root->lchild, visit) )
	{
		if ( PreOrderTraverse(root->rchild, visit) )
		{
			return 1;
		}
	}
 
	return 0;
 
}
 
//中序遍历
int MidOrderTraverse( BiTNode *root, void (*visit)(int) )
{
	if ( NULL == root)
	{
		return 1;
	}
 
	if ( MidOrderTraverse( root->lchild, visit) )
	{
		(*visit)(root->data);
 
		if ( MidOrderTraverse( root->rchild, visit) )
		{
			return 1;
		}
	}
 
	return 0;
}
 
 
//后序遍历
int PostOrderTraverse( BiTNode *root, void (*visit)(int) )
{
	if ( NULL == root)
	{
		return 1;
	}
 
	if ( PostOrderTraverse( root->lchild, visit) )
	{
		if ( PostOrderTraverse( root->rchild, visit) )
		{
			(*visit)(root->data);
 
			return 1;
		}
	}
 
	return 0;
}
 
//先序非递归遍历
int PreOrderNonRecursive( BiTNode *root, void (*visit)(int))
{
	if ( NULL == root)
	{
		return 1;
	}
 
	LinkStack *Stack = NULL;
	int ret = 0;
 
	ret = StackInit(Stack);
	if( FAILURE == ret)
	{
		printf("StackInit error;\n");
	}
 
}
 
 
int main()
{
	int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	BiTNode *root = NULL;
 
	root = CreatTree(a);
 
	PreOrderTraverse( root, print);
 
	printf("\n");
 
	MidOrderTraverse( root, print);
 
	printf("\n");
 
	PostOrderTraverse( root, print);
 
	printf("\n");
	return 0;
}

• /***运行结果***/ 

1 2 4 8 9 5 10 3 6 7

8 4 9 2 10 5 1 6 3 7

8 9 4 10 5 2 6 7 3 1