二叉树遍历算法实现

‘壹’ 二叉树的层次遍历算法

二叉树的层次遍历算法有如下三种方法：

给定一棵二叉树，要求进行分层遍历，每层的节点值单独打印一行，下图给出事例结构：

之后大家就可以自己画图了，下面给出程序代码：

[cpp] view plain

void print_by_level_3(Tree T) {

vector<tree_node_t*> vec;

vec.push_back(T);

int cur = 0;

int end = 1;

while (cur < vec.size()) {

end = vec.size();

while (cur < end) {

cout << vec[cur]->data << " ";

if (vec[cur]->lchild)

vec.push_back(vec[cur]->lchild);

if (vec[cur]->rchild)

vec.push_back(vec[cur]->rchild);

cur++;

}

cout << endl;

}

}

最后给出完成代码的测试用例：124##57##8##3#6##

[cpp] view plain

#include<iostream>

#include<vector>

#include<deque>

using namespace std;

typedef struct tree_node_s {

char data;

struct tree_node_s *lchild;

struct tree_node_s *rchild;

}tree_node_t, *Tree;

void create_tree(Tree *T) {

char c = getchar();

if (c == '#') {

*T = NULL;

} else {

*T = (tree_node_t*)malloc(sizeof(tree_node_t));

(*T)->data = c;

create_tree(&(*T)->lchild);

create_tree(&(*T)->rchild);

}

}

void print_tree(Tree T) {

if (T) {

cout << T->data << " ";

print_tree(T->lchild);

print_tree(T->rchild);

}

}

int print_at_level(Tree T, int level) {

if (!T || level < 0)

return 0;

if (0 == level) {

cout << T->data << " ";

return 1;

}

return print_at_level(T->lchild, level - 1) + print_at_level(T->rchild, level - 1);

}

void print_by_level_1(Tree T) {

int i = 0;

for (i = 0; ; i++) {

if (!print_at_level(T, i))

break;

}

cout << endl;

}

void print_by_level_2(Tree T) {

deque<tree_node_t*> q_first, q_second;

q_first.push_back(T);

while(!q_first.empty()) {

while (!q_first.empty()) {

tree_node_t *temp = q_first.front();

q_first.pop_front();

cout << temp->data << " ";

if (temp->lchild)

q_second.push_back(temp->lchild);

if (temp->rchild)

q_second.push_back(temp->rchild);

}

cout << endl;

q_first.swap(q_second);

}

}

void print_by_level_3(Tree T) {

vector<tree_node_t*> vec;

vec.push_back(T);

int cur = 0;

int end = 1;

while (cur < vec.size()) {

end = vec.size();

while (cur < end) {

cout << vec[cur]->data << " ";

if (vec[cur]->lchild)

vec.push_back(vec[cur]->lchild);

if (vec[cur]->rchild)

vec.push_back(vec[cur]->rchild);

cur++;

}

cout << endl;

}

}

int main(int argc, char *argv[]) {

Tree T = NULL;

create_tree(&T);

print_tree(T);

cout << endl;

print_by_level_3(T);

cin.get();

cin.get();

return 0;

}

‘贰’ 求二叉树遍历算法C语言实现的

Status
PreOrderTraverse
(
BiTree
T,
Status
(
*Visit
)
(
TElemType
e
)
)
{
//
采用二叉链表存储结构，Visit
是对数据元素操作的应用函数，先序遍历二叉树
T
的递归算法。
if
(
T
)
{
//
若
T
不为空
if
(
Visit
(
T->data
)
)
//
调用函数
Visit
if
(
PreOrderTraverse
(
T->lchild,
Visit
)
)
//
递归调用左子树
if
(
PreOrderTraverse
(
T->rchild,
Visit
)
)
return
OK;
//
递归调用右子树
return
ERROR;
}
else
return
OK;
}
//
PreOrderTraverse

‘叁’ 求用C语言实现二叉树层次遍历的递归算法，谢谢！！！

算法思想：层次遍历目前最普遍用的就是队列的那种方式，不是递归，但是用到while循环，既然题目要求用递归，可以用递归实现该while循环功能。算法如下：
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}

Tree *t = DeleteQueue();
TransLevele(t);
}
//测试程序，创建树输入例如ABD##E##C##,根左右创建的方式。
如下代码是测试通过的。
#include "stdlib.h"

#define MAX 100

typedef int Element;

typedef struct tree
{
Element ch;
struct tree *left;
struct tree *right;
}Tree;

typedef struct queue
{
Tree *a[MAX];
int front;
int rear;
}Queue;

Queue Qu;

void Init();
int InsertQueue(Element ch);
Tree *DeleteQueue();

void CreateTree(Tree **r);
void TransLevele(Tree *r);
void PrintTree(Tree *r);

int main()
{
Tree *r=NULL;
CreateTree(&r);
PrintTree(r);
printf("\n");
TransLevele(r);
return 0;
}

void Init()
{
int i=0;
for (i=0; i<MAX; i++)
{
Qu.a[i] = NULL;
}
Qu.front = 0;
Qu.rear = 0;
}
int InsertQueue(Tree *r)
{
if ( (Qu.rear+1)%MAX == Qu.front)
{
printf("Queue full!");
return 0;
}
Qu.a[Qu.rear] = r;
Qu.rear = (Qu.rear+1)%MAX;
return 1;
}
Tree *DeleteQueue()
{
if (Qu.front == Qu.rear)
{
printf("Queue empty");
return NULL;
}
Tree *t=NULL;
t = Qu.a[Qu.front];
Qu.front = (Qu.front+1)%MAX;
return t;
}

void CreateTree(Tree **r)
{
Element ch;
ch=getchar();
if (ch=='#')
{
(*r)=NULL;
return ;
}
*r = (Tree *)malloc(sizeof(Tree));
(*r)->ch = ch;
CreateTree(&((*r)->left));
CreateTree(&((*r)->right));
}
void PrintTree(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
PrintTree(r->left);
PrintTree(r->right);
}
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}

Tree *t = DeleteQueue();
TransLevele(t);
}

‘肆’ 二叉树的遍历算法

递归算法的实现是依据栈来做的，建议你看一下关于这方面的内容。
preorder()函数功能为：若当前结点不为空，则打印当前值，并递归调用打印左右结点。
preorder()函数在每次递归调用前，先将下一条指令地址和参数压栈，即在执行preorder(root->Lchild)前，preorder(root->Rchild)地址及参数压栈。
以后每次递归调用均是如此。
递归函数返回时，也即root=NULL时，当前preoder(root->Rchild)指令出栈，继续向下执行，直到整个递归完成。
对于上述的树，执行过程如下：
1、打印1
2、调用打印2，打印3调用压栈
3、打印2
4、调用打印4，打印5调用压栈
5、打印4
6、调用打印4的左结点，打印4的右结点调用压栈
7、4无左结点，即当前结点=NULL，调用返回
8、栈中弹出打印4右结点调用
9、4无右结点，调用返回
10、栈中弹出打印5的调用
.....
一直这样执行下去，所以打印结果为：1-2-4-5-3-6

‘伍’ 中序遍历二叉树的算法

中序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
(1)遍历左子树；
(2)访问根结点；
(3)遍历右子树。
中序遍历的算法实现
用二叉链表做为存储结构，中序遍历算法可描述为：
void
inorder(bintree
t)
{
//算法里①~⑥是为了说明执行过程加入的标号
①
if(t)
{
//
如果二叉树非空
②
inorder(t->lchild)；
③
printf("％c"，t->data)；
//
访问结点
④
inorder(t->rchild);
⑤
}
⑥
}
//
inorder

‘陆’ 实现二叉树的各种遍历方法

#include <stdlib.h>

struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */

/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{

btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节点指标 */

/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode->data = value; /* 建立节点内容 */
newnode->left = NULL; /* 设定指标初值 */
newnode->right = NULL; /* 设定指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current->data > value ) /* 比较节点值 */
current = current->left; /* 左子树 */
else
current = current->right; /* 右子树 */
}
if ( back->data > value ) /* 接起父子的链结 */
back->left = newnode; /* 左子树 */
else
back->right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}

/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;

for ( i = 0; i < len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data[i]);
return root;
}

/* ---------------------------------------- */
/* 二叉树中序遍历 */
/* ---------------------------------------- */
void inorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
inorder(ptr->left); /* 左子树 */
printf("[%2d]\n",ptr->data); /* 打印节点内容 */
inorder(ptr->right); /* 右子树 */
}
}

/* ---------------------------------------- */
/* 主程式: 建立二叉树且用中序遍历打印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */

/* 二叉树节点数据 */
int data[9] = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
inorder(root); /* 中序遍历二叉树 */
}

/* ======================================== */
/* 二叉树的前序遍历 */
/* ======================================== */
#include <stdlib.h>

struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */

/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{

btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节点指标 */

/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode->data = value; /* 建立节点内容 */
newnode->left = NULL; /* 设定指标初值 */
newnode->right = NULL; /* 设定指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current->data > value ) /* 比较节点值 */
current = current->left; /* 左子树 */
else
current = current->right; /* 右子树 */
}
if ( back->data > value ) /* 接起父子的链结 */
back->left = newnode; /* 左子树 */
else
back->right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}

/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;

for ( i = 0; i < len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data[i]);
return root;
}

/* ---------------------------------------- */
/* 二叉树前序遍历 */
/* ---------------------------------------- */
void preorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
printf("[%2d]\n",ptr->data); /* 打印节点内容 */
preorder(ptr->left); /* 左子树 */
preorder(ptr->right); /* 右子树 */
}
}

/* ---------------------------------------- */
/* 主程式: 建立二叉树且用前序遍历打印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */

/* 二叉树节点数据 */
int data[9] = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
preorder(root); /* 前序遍历二叉树 */
}

/* ======================================== */
/* 二叉树的后序遍历 */
/* ======================================== */
#include <stdlib.h>

struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */

/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{

btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节点指标 */

/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode->data = value; /* 建立节点内容 */
newnode->left = NULL; /* 设定指标初值 */
newnode->right = NULL; /* 设定指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current->data > value ) /* 比较节点值 */
current = current->left; /* 左子树 */
else
current = current->right; /* 右子树 */
}
if ( back->data > value ) /* 接起父子的链结 */
back->left = newnode; /* 左子树 */
else
back->right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}

/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;

for ( i = 0; i < len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data[i]);
return root;
}

/* ---------------------------------------- */
/* 二叉树后序遍历 */
/* ---------------------------------------- */
void postorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
postorder(ptr->left); /* 左子树 */
postorder(ptr->right); /* 右子树 */
printf("[%2d]\n",ptr->data); /* 打印节点内容 */
}
}

/* ---------------------------------------- */
/* 主程式: 建立二叉树且用后序遍历打印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */

/* 二叉树节点数据 */
int data[9] = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
postorder(root); /* 后序遍历二叉树 */
}

‘柒’ 二叉树的遍历算法

这里有二叉树先序、中序、后序三种遍历的非递归算法，此三个算法可视为标准算法。
1.先序遍历非递归算法
#define
maxsize
100
typedef
struct
{

Bitree
Elem[maxsize];

int
top;
}SqStack;
void
PreOrderUnrec(Bitree
t)
{
SqStack
s;
StackInit(s);
p=t;
while
(p!=null
||
!StackEmpty(s))
{
while
(p!=null)
//遍历左子树
{
visite(p->data);
push(s,p);
p=p->lchild;
}//endwhile
if
(!StackEmpty(s))
//通过下一次循环中的内嵌while实现右子树遍历
{
p=pop(s);
p=p->rchild;
}//endif
}//endwhile
}//PreOrderUnrec
2.中序遍历非递归算法
#define
maxsize
100
typedef
struct
{
Bitree
Elem[maxsize];
int
top;
}SqStack;
void
InOrderUnrec(Bitree
t)
{
SqStack
s;
StackInit(s);
p=t;
while
(p!=null
||
!StackEmpty(s))
{
while
(p!=null)
//遍历左子树
{
push(s,p);
p=p->lchild;
}//endwhile
if
(!StackEmpty(s))
{
p=pop(s);
visite(p->data);
//访问根结点
p=p->rchild;
//通过下一次循环实现右子树遍历
}//endif
}//endwhile
}//InOrderUnrec
3.后序遍历非递归算法
#define
maxsize
100
typedef
enum{L,R}
tagtype;
typedef
struct
{
Bitree
ptr;
tagtype
tag;
}stacknode;
typedef
struct
{
stacknode
Elem[maxsize];
int
top;
}SqStack;
void
PostOrderUnrec(Bitree
t)
{
SqStack
s;
stacknode
x;
StackInit(s);
p=t;
do
{
while
(p!=null)
//遍历左子树
{
x.ptr
=
p;
x.tag
=
L;
//标记为左子树
push(s,x);
p=p->lchild;
}
while
(!StackEmpty(s)
&&
s.Elem[s.top].tag==R)
{
x
=
pop(s);
p
=
x.ptr;
visite(p->data);
//tag为R，表示右子树访问完毕，故访问根结点
}
if
(!StackEmpty(s))
{
s.Elem[s.top].tag
=R;
//遍历右子树
p=s.Elem[s.top].ptr->rchild;
}
}while
(!StackEmpty(s));
}//PostOrderUnrec

‘捌’ 二叉树的遍历算法

void
preorder(BiTree
root)
/*先序遍历输出二叉树结点，root为指向二叉树根节点的指针*/
{
if（root!=NULL）
{
printf(root->data);
preorder(root->Lchild);
preorder(root->Rchild);
}
}
你看好这个程序,你首先定义了一个preorder函数,然后在函数体中又调用了本函数,这是函数的自调用.执行printf(root->data);语句的时候输出当前遍历的数据,preorder(root->Lchild);在执行到4的时候,root->Lchild=NULL,但是执行preorder(root->Rchild);语句,由此转向下一个结点,即5

‘玖’ 二叉树的遍历操作实现

// S_lbecs.cpp : 定义控制台应用程序的入口点。
//链表二叉树的定义和操作

#include "stdafx.h"
#include "stdio.h"
#include "malloc.h"
#include "string.h"
#include "stdlib.h"
#define Max 20 //最大节点个数

typedef struct node{
char data;
struct node *lchild,*rchild; //左边孩子的指针 和 右边孩子的指针
}BinTNode;

typedef BinTNode *BinTree; //定义二叉树的指针
int NodeNum,leaf; //NodeNum是结点数 leaf是叶子数

//基于先序遍历算法创建二叉树
//要求输入先序序列，其中加入虚结点“#”以示空指针的位置
BinTree CreatBinTree(void){
BinTree T;
char ch;
scanf("%c",&ch);
if(ch=='#') //读入# 返回空指针
return(NULL);
else{
T=(BinTNode *)malloc(sizeof(BinTNode)); //生成结点

T->data=ch;
T->lchild=CreatBinTree(); //构造左子树
T->rchild=CreatBinTree(); //构造右子树
return(T);
}
}
//DLR 先序遍历
//访问根节点 先序遍历左子树 先序遍历右子树
void Preorde(BinTree T){
if(T){
printf("%c",T->data); //访问结点 D
Preorde(T->lchild); //先序遍历左子树 L
Preorde(T->rchild); //先序遍历右子树 R
}
}
//LDR 中序遍历
void Inorder(BinTree T){
if(T){
Inorder(T->lchild); //中序遍历左子树 L
printf("%c",T->data); //访问结点 D
Inorder(T->rchild); //中序遍历右子树 R
}
}
//LRD 后序遍历
void Postorder(BinTree T){
if(T){
Postorder(T->lchild); //后序遍历左子树 L
Postorder(T->rchild); //后序遍历右子树 R
printf("%c",T->data); //访问结点 D
}
}
//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法
int TreeDepth(BinTree T){
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr?hl:hr; //取最大深度
NodeNum=NodeNum+1; //求结点数
if(hl==0&&hr==0) //若左右深度都为0 则为叶子
leaf=leaf+1;
return(max+1);
}else{
return(0);
}
}
//利用“先进先出”（FIFO）队列，按层次遍历二叉树
void Levelorder(BinTree T){
int front=0,rear=1;
BinTNode *cq[Max],*p; //定义结点的指针数组cq
cq[1]=T; //根入队
while(front!=rear){
front=(front+1)%NodeNum;
p=cq[front]; //出队
printf("%c",p->data); //输出结点的值
if(p->lchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->lchild; //左子树入队
}
if(p->rchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->rchild; //右子树入队
}
}
}

int _tmain(int argc, _TCHAR* argv[])
{
BinTree root;
int i,depth; //最大深度
printf("\n创建二叉树;输入完全二叉树先序序列:");
//用#代表虚结点 如ABD###CE##F##
root=CreatBinTree(); //创建二叉树 返回根结点
printf("\n创建成功!\n");
do{ //从菜单中选择遍历方式，输入序号。
printf("\t********** select ************\n");
printf("\t1: 先序遍历\n");
printf("\t2: 中序遍历\n");
printf("\t3: 后序遍历\n");
printf("\t4: 求树的深度及叶子数\n");
printf("\t5: 按层次遍历\n"); //按层次遍历之前，先选择4，求出该树的结点数。
printf("\t0: 退出\n");
printf("\t*******************************\n请选择:");
scanf("%d",&i); //输入菜单选项 0-5
switch(i){
case 1:
//1: 先序遍历 Preorde
printf("先序遍历的结果是");
Preorde(root); //
printf("\n");
break;
case 2:
//2: 中序遍历 Inorder
printf("中序遍历的结果是");
Inorder(root); //
printf("\n");
break;
case 3:
//3: 后序遍历 Postorder
printf("后序遍历的结果是");
Postorder(root); //
printf("\n");
break;
case 4:
//4: 求树的深度及叶子数 TreeDepth
depth=TreeDepth(root); //
printf("数的深度=%d 结点数=%d",depth,NodeNum);
printf(" 叶子数=%d",leaf);
printf("\n");
break;
case 5:
//5: 按层次遍历 Preorde
printf("按层次遍历的结果是");
Levelorder(root); //
printf("\n");
break;
default:
printf("输入错误\n");
break;
}

}while(i!=0);

return 0;
}

是vs做的 有些地方需要改下 是C语言做的

‘拾’ 怎样实现二叉树的前序遍历的非递归算法

在前面一文，说过二叉树的递归遍历算法（二叉树先根（先序）遍历的改进），此文主要讲二叉树的非递归算法，采用栈结构
总结先根遍历得到的非递归算法思想如下：
1）入栈，主要是先头结点入栈，然后visit此结点
2）while，循环遍历当前结点，直至左孩子没有结点
3）if结点的右孩子为真，转入1）继续遍历，否则退出当前结点转入父母结点遍历转入1）
先看符合此思想的算法：
[cpp]
view
plain

print?
int
(const
BiTree
&T,
int
(*VisitNode)(TElemType
data))
{
if
(T
==
NULL)
{
return
-1;
}
BiTNode
*pBiNode
=
T;
SqStack
S;
InitStack(&S);
Push(&S,
(SElemType)T);
while
(!IsStackEmpty(S))
{
while
(pBiNode)
{
VisitNode(pBiNode->data);
if
(pBiNode
!=
T)
{
Push(&S,
(SElemType)pBiNode);
}
pBiNode
=
pBiNode->lchild;
}
if(pBiNode
==
NULL)
{
Pop(&S,
(SElemType*)&pBiNode);
}
if
(
pBiNode->rchild
==
NULL)
{
Pop(&S,
(SElemType*)&pBiNode);
//如果此时栈已空，就有问题
}
pBiNode
=
pBiNode->rchild;
}
return
0;
}