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;
}