【C/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