BinaryTreeRelatedOperations

最新推荐文章于 2013-12-26 22:40:10 发布

原创最新推荐文章于 2013-12-26 22:40:10 发布 · 628 阅读

0 ·

CC 4.0 BY-SA版权

DataStructure&Algorithms 专栏收录该内容

26 篇文章

订阅专栏

本文介绍了一种二叉树（包括二叉搜索树）的创建方法及遍历算法，并提供了插入节点的不同方式（递归与非递归）。此外，还讨论了如何计算二叉树的节点数与深度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<stdio.h>
#include<malloc.h>
#include<stack>
#include<iostream>

using namespace std;

typedef struct BiTreeNode
{
	int m_nValue;
	struct BiTreeNode* m_pLeft, m_pRight;
}BiTreeNode, *BiTreeList;

class BiTree
{
	static int leaves;
	static int depth;
	BiTreeNode* pRoot;
public:
	//[1].Create a new binary tree(Binary Search Tree)
	BiTreeNode* CreateBiTree(BiTreeNode* pRoot);
	void InsertBSTNode(BiTreeNode* pRoot, int value);
	void InsertBSTNode_Recursively(BiTreeNode* pRoot, int value);

	//[2].Binary Tree Traverse
	void PreorderTraverse_Recursively(BiTreeNode* pRoot);
	void PreorderTraverse(BiTreeNode* pRoot);
	void InorderTraverse(BiTreeNode* pRoot);
	void InorderTraverse_Recursively(BiTreeNode* pRoot);
	void PostorderTraverse(BiTreeNode* pRoot);
	void PostorderTraverse_Recursively(BiTreeNode* pRoot);

	//[3].Basic Operations
	int CalculateTreeNodes(BiTreeNode* pRoot);
	int BiTreeDepth(BiTreeNode* pRoot);
};

//Insert node into binary search tree
//[1].Non-Recursively
void BiTree::InsertBSTNode(BiTreeNode* pRoot, int value)
{
	BiTreeNode* pNode = new BiTreeNode();
	pNode->m_nValue = value;
	pNode->m_pLeft = pNode->m_pRight = NULL;
	
	if(pRoot == NULL)
		pRoot = pNode;
	else
	{
		BiTreeNode* pPrev;
		BiTreeNode* pCurrent = pRoot;
		while(pCurrent != NULL)
		{
			pPrev = pCurrent;
			if(pCurrent->m_nValue > value)
				pCurrent = pCurrent->m_pLeft;
			else
				pCurrent = pCurrent->m_pRight;
		}
		
		if(pPrev->m_nValue > value)
			pPrev->m_nLeft = pNode;
		else
			pPrev->m_nRight = pNode;
	}		
}

//[2]Recursively
void BiTreeNode::InsertBSTNode_Recursively(BiTreeNode* pRoot, int value)
{
	BiTreeNode* pNode = new BiTreeNode();
	pNode->m_nValue = value;
	pNode->m_pLeft = pNode->m_pRight = NULL;
	
	if(pRoot == NULL)
	{
		pRoot = pNode;
		return;
	}
	else
	{
		if(pRoot->m_nValue > value)
		{
			InsertBSTNode_Recursively(pRoot->m_pLeft, value);
		}
		else if(pRoot->m_nValue < value)
		{
			InsertBSTNode_Recursively(pRoot->m_pRight, value);
		}
		else
		{
			cout<<"Insert failed, Current node exists."<<endl;
			return;
		}
	}
}

//[1].Create a new binary tree(Binary Search Tree)
BiTreeNode* BiTree::CreateBiTree(BiTreeNode* pRoot)
{
	int value;
	cin>>value;
	if(value == -1)
		pRoot = NULL;
	else
	{
		pRoot = (BiTreeNode*) malloc(sizeof(BiTreeNode));
		pRoot->m_nValue = value;
		CreateBiTree(pRoot->m_pLeft);
		CreateBiTree(pRoot->m_pRight);
	}	
	
	return pRoot;
}

/*Traverse Binary Tree in different orders----- Recursively*/
//[1].PreorderTraverse
void BiTree::PreorderTraverse_Recursively(BiTreeNode* pRoot)
{
	if(NULL == pRoot)
		return;
	cout<<pRoot->m_nValue<<" ";
	PreorderTraverse_Recursively(pRoot->m_pLeft);
	PreorderTraverse_Recursively(pRoot->m_pRight);
}

//[2].InorderTraverse
void BiTree::InorderTraverse_Recursively(BiTreeNode* pRoot)
{
	if(NULL == pRoot)
		return;
	
	InorderTraverse_Recursively(pRoot->m_pLeft);
	cout<<pRoot->m_nValue<<" ";
	InorderTraverse_Recursively(pRoot->m_pRight);
}

//[3].PostorderTraverse
void BiTree::PostorderTraverse_Recursively(BiTreeNode* pRoot)
{
	if(NULL == pRoot)
		return;
	
	PostorderTraverse_Recursively(pRoot->m_pLeft);
	PostorderTraverse_Recursively(pRoot->m_pRight);
	cout<<pRoot->m_nValue<<" ";
}

/*Binary Tree Traverse -- Non_Recursively*/
//[1].Preorder
void visit(BiTreeNode* pRoot)
{
	if(pRoot)
	{
		cout<<pRoot->m_nValue<<" ";
	}
}

void BiTree::PreorderTraverse(BiTreeNode* pRoot)
{
	BiTreeNode* pNode = pRoot;
	stack<BiTreeNode*> nodes;
	
	while(pNode != NULL || !nodes.empty())
	{
		if(pNode != NULL)
		{
			visit(pNode);
			nodes.push(pNode);
			pNode = pNode->m_pLeft;
		}
		else
		{
			pNode = nodes.top();
			nodes.pop();
			pNode = pNode->m_pRight;
		}
	}
}

//[2].Inorder
void BiTree::InorderTraverse(BiTreeNode* pRoot)
{
	BiTreeNode* pNode = pRoot;
	stack<BiTreeNode*> nodes;
	
	while(pNode != NULL || !nodes.empty())
	{
		while(pNode != NULL)
		{
			nodes.push(pNode);
			pNode = pNode->m_pLeft;
		}
		if(!nodes.empty())
		{
			pNode = nodes.top();
			nodes.pop();
			visit(pNode);
			pNode = pNode->m_pRight;
		}
	}
}

//[3].Postorder
typedef enum{L, R}TagType;
typedef struct
{
	BiTreeNode* pNode;
	TagType tag;
}StackNode;

void BiTree::PostorderTraverse(BiTreeNode* pRoot)
{
	BiTreeNode* pNode = pRoot;
	stack<StackNode> nodes;
	StackNode snode = new StackNode();
	
	do{
		while(pNode != NULL)
		{
			snode.pNode = pNode;
			snode.tag = L;
			nodes.push(snode);
			pNode = pNode->m_pLeft;
		}
		
		while(!nodes.empty() && nodes.top().tag == R)
		{
			snode = nodes.top();
			nodes.pop();
			
			visit(snode.pNode);
		}
		
		if(!nodes.empty())
		{
			nodes.top().tag = R;
			pNode = nodes.top().pNode->m_pRight;
		}
	
	}while(!nodes.empty());
}

//[3].Basic Operations
int BiTree::CalculateTreeNodes(BiTreeNode* pRoot)
{
	int nodeSum = 0;
	nodeSum = CalculateTreeNodesCore(pRoot);
	
	return nodeSum;
}

int CalculateTreeNodesCore(BiTreeNode* pRoot)
{
	if(NULL == pRoot)
	{
		return 0;
	}
	
	int left = CalculateTreeNodesCore(pRoot->m_pLeft);
	int right = CalculateTreeNodesCore(pRoot->m_pRight);
	
	return left + right + 1;
}

int BiTree::BiTreeDepth(BiTreeNode* pRoot)
{
	if(pRoot == NULL)
		return 0;
	// if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)
		// return 1;
	int left = BiTreeDepth(pRoot->m_pLeft);
	int right = BiTreeDepth(pRoot->m_pRight);
	
	return 1 + (left > right) ? left: right;
}