二叉树的基本操作

#pragma once


/////////////
//////.h

typedef char DataType;

typedef struct BinTreeNode
{
	struct BinTreeNode* _pLeft;
	struct BinTreeNode* _pRight;
	DataType _data;
}Node,*PNode;



PNode BuyBinTreeNode(DataType data);
void _CreateBinTree(PNode *pRoot,DataType array[],int size,int *index,DataType invalid);
void CreateBinTree(PNode *pRoot,DataType array[],int size,DataType invalid);
PNode CopyBinTree(PNode pRoot);
void PreTree(PNode pRoot);
void InOrder(PNode pRoot);
void PostOrder(PNode pRoot);
void DestroyBinTree(PNode *pRoot);
void TestBinTree();

///////////////////////
//////////////////.c

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>


//开辟内存空间
PNode BuyBinTreeNode(DataType data)
{
	PNode pNewNode = (PNode) malloc (sizeof(Node));
	if(NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode ->_data = data;
	pNewNode ->_pLeft = NULL;
	pNewNode ->_pRight = NULL;
	return pNewNode;
}


//创建二叉树
void _CreateBinTree(PNode *pRoot,DataType array[],int size,int *index,DataType invalid)
{
	if(*index < size  && invalid != array[*index])
	{
		*pRoot = BuyBinTreeNode(array[*index]);
		//创建根节点的左子树
		++(*index);
		_CreateBinTree(&(*pRoot)->_pLeft,array,size,index,invalid);
		//创建根节点的右子树
		++(*index);
		_CreateBinTree(&(*pRoot)->_pRight,array,size,index,invalid);

	}
}

//封装
void CreateBinTree(PNode *pRoot,DataType array[],int size,DataType invalid)
{
	int index = 0;
	_CreateBinTree(pRoot,array,size,&index,invalid);
}


//拷贝二叉树
PNode CopyBinTree(PNode pRoot)
{
	PNode pNewRoot = NULL;
	if(pRoot)
	{
		pNewRoot = BuyBinTreeNode(pRoot->_data);
		if(pRoot -> _pLeft)
			pNewRoot ->_pLeft = CopyBinTree(pRoot->_pLeft);
		if(pRoot -> _pRight)
			pNewRoot ->_pRight = CopyBinTree(pRoot->_pRight);
	}
	return pNewRoot;
}


//前序遍历
void PreOrder(PNode pRoot)
{
	if(pRoot)
	{
		printf("%c  ",pRoot->_data);
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}
}
//中序遍历
void InOrder(PNode pRoot)
{
	if(pRoot)
	{
		
		InOrder(pRoot->_pLeft);
		printf("%c  ",pRoot->_data);
		InOrder(pRoot->_pRight);
	}
}
//后序遍历
void PostOrder(PNode pRoot)
{
	if(pRoot)
	{
		
		PostOrder(pRoot->_pLeft);
		PostOrder(pRoot->_pRight);
		printf("%c  ",pRoot->_data);
	}
}


//销毁二叉树
void DestroyBinTree(PNode *pRoot)
{
	assert(pRoot);
	if(*pRoot)
	{
		DestroyBinTree(&(*pRoot)->_pLeft);
		DestroyBinTree(&(*pRoot)->_pRight);
		free(*pRoot);
		*pRoot = NULL;
	}
}


//测试
void TestBinTree()
{
	char *str = "ABD###CE##F";
	PNode pRoot = NULL , pNewRoot = NULL;
	CreateBinTree(&pRoot,str,strlen(str),'#');
	pNewRoot = CopyBinTree(pRoot);


	//前序遍历
	PreOrder(pRoot);
	printf("\n");

	//中序遍历
	InOrder(pRoot);
	printf("\n");

	//后序遍历
	PostOrder(pRoot);
	printf("\n");
}

#include <stdlib.h>
#include "BinaryTree.h"

int main()
{
	TestBinTree();
	system("pause");
	return 0;
}