二叉链表类的声明
template
<class T>
struct
BiNode //
二叉树的结点结构
{
T data;
BiNode<T> *lchild, *rchild;
};
template
<class T>
struct
element
{
BiNode<T> *ptr;
int flag;
};
template
<class T>
class
BiTree
{
public
:
BiTree( ); //
构造函数,初始化一棵二叉树,其前序序列由键盘输入
~BiTree(void); //
析构函数,释放二叉链表中各结点的存储空间
BiNode<T>* Getroot(); //
获得指向根结点的指针
void PreOrder(BiNode<T> *root); //
前序遍历二叉树
void InOrder(BiNode<T> *root); //
中序遍历二叉树
void PostOrder(BiNode<T> *root); //
后序遍历二叉树
void LeverOrder(BiNode<T> *root); //
层序遍历二叉树
private
:
BiNode<T> *root; //
指向根结点的头指针
BiNode<T> *Creat(); //
有参构造函数调用
void Release(BiNode<T> *root); //
析构函数调用
};
|
构造函数算法:
template
<class T>
BiTree<T>::BiTree()
{
this->root = Creat();
}
template
<class T>
BiNode<T>* BiTree<T>::Getroot( )
{
return root;
}
template
<class T>
BiNode<T>* BiTree<T>::Creat( )
{
BiNode<T>* root;
T ch;
cout<<"
请输入创建一棵二叉树的结点数据"
<<endl;
cin >> ch;
if (ch=="#") root = NULL;
else{
root = new BiNode<T>; //
生成一个结点
root->data=ch;
root->lchild = Creat(); //
递归建立左子树
root->rchild = Creat(); //
递归建立右子树
}
return root;
}
|
析构函数算法:
template
<class T>
BiTree<T>::~BiTree(void)
{
Release(root);
}
template
<class T>
void
BiTree<T>::Release(BiNode<T>* root)
{
if (root != NULL){
Release(root->lchild); //
释放左子树
Release(root->rchild); //
释放右子树
delete root;
}
}
|
前序遍历
(1)
访问根结点;
(2)
前序遍历根结点的左子树;
(3)
前序遍历根结点的右子树;
递归算法:
template
<class T>
void
BiTree<T>::PreOrder(BiNode<T> *root)
{
if (root == NULL) return;
else {
cout << root->data << ' ';
PreOrder(root->lchild);
PreOrder(root->rchild);
}
}
|
非递归算法:
template
<class T>
void
BiTree<T>::PreOrder(BiNode<T> *root)
{
int top = -1;
const int MaxSize = 100;
BiNode<T> *s[MaxSize];
while (root != NULL || top != -1)
{
while (root != NULL)
{
cout << root->data << " ";
s[++top] = root;
root = root->lchild;
}
if (top != -1)
{
root = s[top--];
root = root->rchild;
}
}
}
|
中序遍历:
(1)
中序遍历根结点的左子树
(2)
访问根结点;
(3)
中序遍历根结点的右子树
递归算法
template
<class T>
void
BiTree<T>::InOrder(BiNode<T> * root)
{
if (root == NULL) return;
else {
InOrder(root->lchild);
cout << root->data << " ";
InOrder(root->rchild);
}
}
|
非递归算法:
template
<class T>
void
BiTree<T>::InOrder(BiNode<T> *root)
{
int top = -1;
const int MaxSize = 100;
BiNode<T> *s[MaxSize];
while (root != NULL || top != -1)
{
while (root != NULL){
s[++top] = root;
root = root->lchild;
}
if (top != -1)
{
root = s[top--];
cout << root->data << " ";
root = root->rchild;
}
}
}
|
后序遍历:
(1
)后序遍历根结点的左子树;
(2
)后序遍历根结点的右子树;
(3
)访问根结点;
递归算法:
template
<class T>
void
BiTree<T>::PostOrder(BiNode<T> *root)
{
if (root == NULL) return;
else
{
PostOrder(root->lchild);
PostOrder(root->rchild);
cout << root->data << " ";
}
}
|
非递归算法:
Flag=1
第一次出栈,只遍历完左子树,该结点不能被访问
Flag=2
第二次出栈,遍历完右子树,该结点可以被访问
template
<class T>
struct
BiNode //
二叉树的结点结构
{
T data;
BiNode<T> *lchild, *rchild;
};
template
<class T>
void
BiTree<T>::PostOrder(BiNode<T> *root)
{
int top = -1;
const int MaxSize = 100;
element<T> s[MaxSize];
while (root != NULL || top != -1)
{
while (root != NULL)
{
top ++;
s[top].ptr = root;
s[top].flag = 1;
root = root->lchild;
}
while (top != -1 && s[top].flag == 2)
{
root = s[top--].ptr;
cout << root->data << " ";
}
if (top != -1)
{
s[top].flag = 2;
root = s[top].ptr;
root = root->rchild;
}
else return;
}
}
|
层序遍历:
用队列来实现:
template
<class T>
void
BiTree<T>::LeverOrder(BiNode<T> *root)
{
const int MaxSize = 100;
int front = 0;
int rear = 0;
BiNode<T>* Q[MaxSize];
BiNode<T>* q;
if (root == NULL) return;
else{
Q[rear++] = root;
while (front != rear)
{
q = Q[front++];
cout<< q->data << " ";
if (q->lchild != NULL) Q[rear++] = q->lchild;
if (q->rchild != NULL) Q[rear++] = q->rchild;
}
}
}
|