二叉树 - 二叉排序树

binarytree.h

/********************************************************************
    purpose:    二叉排序树
    author:     xianyun1230
    QQ:         836663997
    e-mail:     xianyun1230@163.com
    created:    2014/02/25
	explain:
		按层遍历中使用了List 保存指针
*********************************************************************/


#include <iostream>
#include "List.h"

template <typename T>
class binarytree
{
	public:
		binarytree(T initval);
		~binarytree();
		void insert(const T val);
		int high() {return treehigh(tree);}
		int number() {return treenumber(tree);}
		bool find(const T val);
		void preorder() {::PreOrder(tree);}
		void inorder() {::InOrder(tree);}
		void postorder() {::PostOrder(tree);}
		void levelorder() {::LevelOrder(tree);}
	private:
		typedef struct _treenode
		{
			T data;
			struct _treenode *left, *right;
		}treenode;
		friend class queue;
		friend void PreOrder(binarytree<T>::treenode *tnode);
		friend void InOrder(binarytree<T>::treenode *tnode);
		friend void PostOrder(binarytree<T>::treenode *tnode);
		friend void LevelOrder(binarytree<T>::treenode *tnode);
		friend void delbinary(treenode *tnode);
		friend int main();
		treenode *tree;
};
template <typename T> int treehigh(binarytree<T>::treenode *tnode);
template <typename T> int treenumber(binarytree<T>::treenode *tnode);

template <typename T>
binarytree<T>::binarytree(T initval)
{
	tree = new treenode;
	tree->data = initval;
	tree->left = tree->right = NULL;
}
template <typename T>
binarytree<T>::~binarytree()
{
	delbinary(tree);
}
template <typename T>
void delbinary(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		if (tnode->left)
			delbinary(tnode->left);
		if (tnode->right)
			delbinary(tnode->right);
	}
}
template <typename T>
void binarytree<T>::insert(const T val)
{
	treenode *tmp = new treenode;
	tmp->data = val;
	tmp->left = tmp->right = NULL;
	treenode *pt = tree;
	while (pt)
	{
		if (val < pt->data)
		{
			if (pt->left != NULL)
				pt = pt->left;
			else
			{
				pt->left = tmp;
				break;
			}
		}
		else
		{
			if (pt->right != NULL)
				pt = pt->right;
			else
			{
				pt->right = tmp;
				break;
			}
		}
	}
}
template <typename T>
bool binarytree<T>::find(const T val)
{
	treenode *pt = tree;
	while (pt)
	{
		if (pt->data == val)
			return true;
		if (val < pt->data)
			pt = pt->left;
		else
			pt = pt->right;
	}
	return false;
}
template <typename T>
void PreOrder(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		Visit(tnode);
		PreOrder(tnode->left);
		PreOrder(tnode->right);
	}
}
template <typename T>
void InOrder(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		InOrder(tnode->left);
		Visit(tnode);
		InOrder(tnode->right);
	}
}
template <typename T>
void PostOrder(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		PostOrder(tnode->left);
		PostOrder(tnode->right);
		Visit(tnode);
	}
}
template <typename T>
void LevelOrder(binarytree<T>::treenode *tnode)
{
	List<binarytree<T>::treenode*> que;
	while (tnode)
	{  
		Visit(tnode);
		if (tnode->left)
			que.push_back(tnode->left);
		if (tnode->right)
			que.push_back(tnode->right);
		if (que.empty())
			break;
		que.pop_front(tnode);
	}
}
template <typename T>
void Visit(binarytree<T>::treenode *tnode)
{
	std::cout <<tnode->data <<" ";
}

template <typename T> int treehigh(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		int l = treehigh(tnode->left) + 1;
		int r = treehigh(tnode->right) + 1;
		return (l > r)? l : r;
	}
	return 0;
}
template <typename T> int treenumber(binarytree<T>::treenode *tnode)
{
	if (tnode)
	{
		return treenumber(tnode->left) + treenumber(tnode->right) + 1;
	}
	return 0;
}

List.h

/********************************************************************
    purpose:    带头结点的双链表
    author:     xianyun1230
    QQ:         836663997
    e-mail:     xianyun1230@163.com
    created:    2014/02/18
*********************************************************************/
template<typename T>
class List
{
	public:
		List();
		~List();
		bool push_back(const T &val);	//末尾插入数据
		bool push_front(const T &val);	//开头插入数据
		bool pop_front(T &val);	//开头删除数据
		bool pop_back(T &val);
		bool empty(){return _size == 0;}
		unsigned int size() const {return _size;}	//返回元素个数

	private:
		typedef struct _Node
		{
			T data;
			_Node *next, *front;
		}Node;
		Node * head, * end;	//分别指向头结点、尾指针
		unsigned int _size;		//元素数
};
template<typename T>
List<T>::List()	//默认构造函数，创建头尾结点，元素数为0
{
	_size = 0;
	head = new Node;
	head->front = head;
	head->next = head;
	end = head;
}
template<typename T>
List<T>::~List()
{
	Node * ph = head, *pt = head->next;
	while(pt != head)
	{
		ph = pt->next;
		delete pt;
		pt = ph;
	}
}
template<typename T>
bool List<T>::push_back(const T & val)
{
	Node *temp = new Node;	//temp用作新尾,next属性设为head以循环(循环链表)
	temp->front = end;
	temp->data = val;
	temp->next = head;
	end->next = temp;
	end = temp;		//指向新尾
	++_size;
	return true;
}
template<typename T>
bool List<T>::push_front(const T &val)
{
	Node *temp = new Node;  
	temp->front = head;
	temp->data = val;
	temp->next = head->next;
	head->next = temp;
	++_size;
	return true;
}
template<typename T>
bool List<T>::pop_front(T &val)
{
	if (_size == 0)
		return false;
	Node *temp = head->next;
	val = temp->data;		//用于返回值
	head->next = temp->next;
	temp->next->front = head;
	delete temp;
	--_size;
	if (_size == 0)
		end = head;
	return true;
}
template<typename T>
bool List<T>::pop_back(T &val)
{
	if (_size == 0)
		return false;
	Node *temp = end;
	val = end->data;		//用于返回值
	end = end->front;
	end->next = head;
	delete temp;
	--_size;
	if (_size == 0)
		end = head;
	return true;
}

1.cpp

#include "binarytree.h"

int main()
{
	binarytree<int> tree(12);
	for (int i = 0; i < 20; i++)
		tree.insert(rand()%300);
	tree.inorder();
	std::cout <<std::endl;
	tree.levelorder();
	std::cout <<std::endl <<tree.high() <<std::endl << tree.number() <<std::endl;
	return 0;
}