二叉树简单实现

// ChainTree.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <IOSTREAM>
#include <CSTDIO>
#include <CSTDLIB>
#include <CSTRING>
#include <CONIO.H>

using namespace std;

#define MAXLEN 20

// data
typedef char DATA;

typedef struct CBT{
	DATA data;
	struct CBT *left;
	struct CBT *right;
}CBTType;


// init 
CBTType *InitTree()
{
	CBTType *node;

	if (node = (CBTType *) malloc(sizeof(CBTType)))
	{
		cout<<"enter root data: "<<endl;
		cin>>node->data;
		node->left = NULL;
		node->right = NULL;
		if(node != NULL)
		{
			return node;
		}
		else
		{
			return NULL;
		}
	}
	return NULL;
}



// Find
CBTType * TreeFindNode(CBTType *treeNode, DATA data)
{
	CBTType *ptr;
	
	if(treeNode == NULL)
	{
		return NULL;
	}
	else
	{
		if(treeNode->data == data)
		{
			return treeNode;
		}
		else
		{
			if (ptr = TreeFindNode(treeNode->left, data))
			{
				return ptr;
			}
			else if(ptr = TreeFindNode(treeNode->right, data))
			{
				return ptr;
			}
			else
			{
				return NULL;
			}
		}
	}
}

// add
void AddTreeNode(CBTType *treeNode)
{
	CBTType *pnode, *parent;	
	DATA data;
	char menusel;

	if(pnode = (CBTType *)malloc(sizeof(CBTType)))
	{
		cout<<"enter ChainTree Data: "<<endl;
		fflush(stdin);
		cin>>pnode->data;
		pnode->left = NULL;
		pnode->right = NULL;

		cout<<"enter node parent data: "<<endl;
		fflush(stdin);
		cin>>data;
		parent = TreeFindNode(treeNode, data);
		if (!parent)
		{
			cout<<"not found data!"<<endl;
			free(pnode);
			return;
		}
		cout<<"add node left tree"<<endl<<"add node right tree"<<endl;
		do 
		{
			fflush(stdin);
			menusel = getch();
			menusel -= '0';
			if (menusel == 1 || menusel == 2)
			{
				if (parent == NULL)
				{
					cout<<"parent no exits, set parent then to try!"<<endl;
				}
				else
				{
					switch(menusel)
					{
					case 1:
						{
							if(parent->left)
							{
								cout<<"tree node left not empty!"<<endl;
							}
							else
							{
								parent->left = pnode;
							}
						}
						break;
					case 2:
						{
							if (parent->right)
							{
								cout<<"tree node right not empty!"<<endl;
							}
							else
							{
								parent->right = pnode;
							}
						}
						break;
					default:
						cout<<"invad param!"<<endl;
						break;
					}
				}
			}
		} while (menusel != 1 && menusel != 2);
	}
}


// find tree Left

CBTType *TreeLeftNode(CBTType *treeNode)
{
	if (treeNode)
	{
		return treeNode->left;
	}
	else
	{
		return NULL;
	}
}

// find right tree
CBTType *TreeRightNode(CBTType *treeNode)
{
	if (treeNode)
	{
		return treeNode->right;
	}
	else
	{
		return NULL;
	}
}
// Empty
int TreeIsEmpty(CBTType *treeNode)
{	
	if(treeNode)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

// Depth

int TreeDepth(CBTType *treeNode)
{
	int depleft, depright;

	if (treeNode == NULL)
	{
		return 0;
	}
	else
	{
		depleft = TreeDepth(treeNode->left);
		depright = TreeDepth(treeNode->right);
		if (depleft > depright)
		{
			return depleft + 1;
		} 
		else
		{
			return depright + 1;
		}
	}
}

// Clear
void ClearTree(CBTType *treeNode)
{
	if (treeNode)
	{
		ClearTree(treeNode->left);
		ClearTree(treeNode->right);
		free(treeNode);
		treeNode = NULL;
	}
}


// show 
void TreeNodeData(CBTType *p)
{
	cout<<p->data<<endl;
}


// Level
void LevelTree(CBTType *treeNode, void (*TreeNodeData)(CBTType *p))
{
	CBTType *p;
	CBTType *q[MAXLEN];
	int head = 0, tail = 0;

	if (treeNode)
	{
		tail = (tail + 1) % MAXLEN;
		q[tail] = treeNode;
	}

	while(head != tail)
	{
		head = (head + 1) % MAXLEN;
		p = q[head];
		TreeNodeData(p);
		if (p->left != NULL)
		{
			tail = (tail + 1) % MAXLEN;
			q[tail] = p->left;
		}
		if (p->right != NULL)
		{
			tail = (tail + 1) % MAXLEN;
			q[tail] = p->right;
		}
	}
}
// 遍历
void DLRTree(CBTType *treeNode, void (*TreeNodeData)(CBTType *p))
{
	if (treeNode)
	{
		TreeNodeData(treeNode);
		DLRTree(treeNode->left, TreeNodeData);
		DLRTree(treeNode->right, TreeNodeData);
	}
}


// 中序遍历
void LDRTree(CBTType *treeNode, void (*TreeNodeData)(CBTType *p))
{
	if (treeNode)
	{
		LDRTree(treeNode->left, TreeNodeData);
		TreeNodeData(treeNode);
		LDRTree(treeNode->right, TreeNodeData);
	}
}

// 后序遍历
void LRDTree(CBTType *treeNode, void(*TreeNodeData)(CBTType *p))
{
	if (treeNode)
	{
		LRDTree(treeNode->left, TreeNodeData);
		LRDTree(treeNode->right, TreeNodeData);
		TreeNodeData(treeNode);
	}
}

int main(int argc, char* argv[])
{
	CBTType * root = NULL;
	char menusel;
	void(*TreeNodeData1)(CBTType*);					// 指向函数的指针
	TreeNodeData1 = TreeNodeData;

	// set root
	root = InitTree();
	
	// add
	do 
	{
		cout<<"choice tree node to add!"<<endl;
		cout<<"0 exit"<<endl;
		cout<<"1 add node"<<endl;
		menusel = getch();

		switch(menusel)
		{
		case '1':
			{
				AddTreeNode(root);
			}
			break;
		case '0':
			{
			}
			break;
		default:
			cout<<"invaid param!"<<endl;
			break;
		}

	} while (menusel != '0');

	 // show 
	do 
	{
		cout<<"show ChainTree, enter 0  exit"<<endl;
		cout<<"1. DLR"<<endl;
		cout<<"2. LDR"<<endl;
		cout<<"3. LRD"<<endl;
		cout<<"4. Level"<<endl;

		menusel = getch();
		switch(menusel)
		{
		case '0':
			break;
		case '1':
			{
				cout<<"DLR"<<endl;
				DLRTree(root, TreeNodeData1);
				cout<<endl;
			}
		
			break;
		case '2':
			{
				cout<<"LDR"<<endl;
				LDRTree(root, TreeNodeData1);
				cout<<endl;
			}
			break;
		case '3':
			{
				cout<<"LRD"<<endl;
				LRDTree(root, TreeNodeData1);
				cout<<endl;
			}
			break;
		case '4':
			{
				cout<<"Level"<<endl;
				LevelTree(root, TreeNodeData1);
				cout<<endl;
			}
			break;
		default:
			cout<<"invaid param!"<<endl;
			break;
		}

	} while (menusel != '0');

	cout<<"Chain Depth: "<<TreeDepth(root)<<endl;

	ClearTree(root);

	root = NULL;

	return 0;
}