请问如何用随机函数生成二叉树，并遍历？

Posted 2023-03-30

请问如何利用随机函数产生100个(不大于100且各不相同的)随机整数，用这些整数来生成一棵二叉树，分别对二叉树进行先序遍历，中序遍历和后序列遍历输出树中结点元素序列。
注：先序遍历输出要求采用非递归来实现。

这是我刚做好的，你下载一个dev-cpp软件，把这个复制进去编译就行了。
数据结构课程设计源程序
注：main函数在最后，这样编译时就不用声明其他要用的函数。

#include<stdio.h>
#include<malloc.h>
#include<math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status ;
//函数状态类型
typedef int ElemType ;
//二叉树结点数据类型为整型
#define FORMAT "%d "
//输出格式与ElemType对应

void RandomHundred(int ran[100])
//产生100个不大于100且各不相同的整数，存放在ran[100]中
int i,temp,ransubscript ;
//temp用于交换，ransubscript为随机下标
for(i=1;i<101;++i)ran[i-1]=i ;
//先把1－100按顺序放入数组中
for(i=100;i>0;--i)
ransubscript=rand()%i ;
//产生随机下标
temp=ran[i-1];
ran[i-1]=ran[ransubscript];
ran[ransubscript]=temp ;
//交换ran[i-1]与ran[ransubscript]
typedef struct BSTNode
ElemType data ;
int bf ;
/*结点的平衡因子*/
struct BSTNode*lchild,*rchild ;
/* 左、右孩子指针 */BSTNode,*BSTree ;
#define EQ(a,b)((a)==(b))
#define LT(a,b)((a)<(b))
#define LH +1 /* 左高 */
#define EH 0 /* 等高 */
#define RH -1 /* 右高 */
void R_Rotate(BSTree*p)
/* 对以*p为根的二叉排序树作右旋处理，处理之后p指向新的树根结点，即旋转 */
/* 处理之前的左子树的根结点。算法9.9 */
BSTree lc ;
lc=(*p)->lchild ;
/* lc指向p的左子树根结点 */
(*p)->lchild=lc->rchild ;
/* lc的右子树挂接为p的左子树 */
lc->rchild=*p ;
*p=lc ;
/* p指向新的根结点 */

void L_Rotate(BSTree*p)
/* 对以*p为根的二叉排序树作左旋处理，处理之后p指向新的树根结点，即旋转 */
/* 处理之前的右子树的根结点。算法9.10 */
BSTree rc ;
rc=(*p)->rchild ;
/* rc指向p的右子树根结点 */
(*p)->rchild=rc->lchild ;
/* rc的左子树挂接为p的右子树 */
rc->lchild=*p ;
*p=rc ;
/* p指向新的根结点 */

void LeftBalance(BSTree*T)
/* 对以指针T所指结点为根的二叉树作左平衡旋转处理，本算法结束时， */
/* 指针T指向新的根结点。算法9.12 */
BSTree lc,rd ;
lc=(*T)->lchild ;
/* lc指向*T的左子树根结点 */
switch(lc->bf)
/* 检查*T的左子树的平衡度，并作相应平衡处理 */
case LH :
/* 新结点插入在*T的左孩子的左子树上，要作单右旋处理 */
(*T)->bf=lc->bf=EH ;
R_Rotate(T);
break ;
case RH :
/* 新结点插入在*T的左孩子的右子树上，要作双旋处理 */
rd=lc->rchild ;
/* rd指向*T的左孩子的右子树根 */
switch(rd->bf)
/* 修改*T及其左孩子的平衡因子 */
case LH :
(*T)->bf=RH ;
lc->bf=EH ;
break ;
case EH :
(*T)->bf=lc->bf=EH ;
break ;
case RH :
(*T)->bf=EH ;
lc->bf=LH ;
break ;
rd->bf=EH ;
L_Rotate(&(*T)->lchild);
/* 对*T的左子树作左旋平衡处理 */
R_Rotate(T);
/* 对*T作右旋平衡处理 *

void RightBalance(BSTree*T)
/* 对以指针T所指结点为根的二叉树作右平衡旋转处理，本算法结束时， */
/* 指针T指向新的根结点 */
BSTree rc,rd ;
rc=(*T)->rchild ;
/* rc指向*T的右子树根结点 */
switch(rc->bf)
/* 检查*T的右子树的平衡度，并作相应平衡处理 */
case RH :
/* 新结点插入在*T的右孩子的右子树上，要作单左旋处理 */
(*T)->bf=rc->bf=EH ;
L_Rotate(T);
break ;
case LH :
/* 新结点插入在*T的右孩子的左子树上，要作双旋处理 */
rd=rc->lchild ;
/* rd指向*T的右孩子的左子树根 */
switch(rd->bf)
/* 修改*T及其右孩子的平衡因子 */
case RH :
(*T)->bf=LH ;
rc->bf=EH ;
break ;
case EH :
(*T)->bf=rc->bf=EH ;
break ;
case LH :
(*T)->bf=EH ;
rc->bf=RH ;
break ;
rd->bf=EH ;
R_Rotate(&(*T)->rchild);
/* 对*T的右子树作右旋平衡处理 */
L_Rotate(T);
/* 对*T作左旋平衡处理 */

Status InsertAVL(BSTree*T,ElemType e,Status*taller)
/* 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个 */
/* 数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树 */
/* 失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。算法9.11 */
if(!*T)
/* 插入新结点，树“长高”，置taller为TRUE */
*T=(BSTree)malloc(sizeof(BSTNode));
(*T)->data=e ;
(*T)->lchild=(*T)->rchild=NULL ;
(*T)->bf=EH ;
*taller=TRUE ;
else
if(EQ(e,(*T)->data))
/* 树中已存在和e有相同关键字的结点则不再插入 */
*taller=FALSE ;
return FALSE ;
if(LT(e,(*T)->data))
/* 应继续在*T的左子树中进行搜索 */
/* 未插入 */
if(!InsertAVL(&(*T)->lchild,e,taller))return FALSE ;
/* 已插入到*T的左子树中且左子树“长高” */
/* 检查*T的平衡度 */
if(*taller)switch((*T)->bf)
case LH :
/* 原本左子树比右子树高，需要作左平衡处理 */
LeftBalance(T);
*taller=FALSE ;
break ;
case EH :
/* 原本左、右子树等高，现因左子树增高而使树增高 */
(*T)->bf=LH ;
*taller=TRUE ;
break ;
case RH :
(*T)->bf=EH ;
/* 原本右子树比左子树高，现左、右子树等高 */
*taller=FALSE ;
else
/* 应继续在*T的右子树中进行搜索 */
/* 未插入 */
if(!InsertAVL(&(*T)->rchild,e,taller))return FALSE ;
/* 已插入到T的右子树且右子树“长高” */
/* 检查T的平衡度 */
if(*taller)switch((*T)->bf)
case LH :
(*T)->bf=EH ;
/* 原本左子树比右子树高，现左、右子树等高 */
*taller=FALSE ;
break ;
case EH :
/* 原本左、右子树等高，现因右子树增高而使树增高 */
(*T)->bf=RH ;
*taller=TRUE ;
break ;
case RH :
/* 原本右子树比左子树高，需要作右平衡处理 */
RightBalance(T);
*taller=FALSE ;
return TRUE ;

typedef BSTree SElemType;//这个很重要，定义栈的元素类型为二叉树结点指针BSTree
//栈的顺序存储表示
//SElemType为栈元素，由用户在主函数中定义
#define STACK_INIT_SIZE 100 /* 存储空间初始分配量 */
#define STACKINCREMENT 10 /* 存储空间分配增量 */
typedef struct SqStack
SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
SElemType *top; /* 栈顶指针 */
int stacksize; /* 当前已分配的存储空间，以元素为单位 */
SqStack; /* 顺序栈 */
//顺序栈（存储结构由SqStack.h定义）的基本操作
Status InitStack(SqStack *S)
/* 构造一个空栈S */
(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!(*S).base)
exit(OVERFLOW); /* 存储分配失败 */
(*S).top=(*S).base;
(*S).stacksize=STACK_INIT_SIZE;
return OK;

Status StackEmpty(SqStack S)
/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
if(S.top==S.base)
return TRUE;
else
return FALSE;

Status Push(SqStack *S,SElemType e)
/* 插入元素e为新的栈顶元素 */
if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */
(*S).base=(SElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!(*S).base)
exit(OVERFLOW); /* 存储分配失败 */
(*S).top=(*S).base+(*S).stacksize;
(*S).stacksize+=STACKINCREMENT;
*((*S).top)++=e;
return OK;

Status Pop(SqStack *S,SElemType *e)
/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
if((*S).top==(*S).base)
return ERROR;
*e=*--(*S).top;
return OK;
void PreOrderTraverse(BSTree T,Status(*Visit)(ElemType e))
//非递归先序遍历二叉树
BSTree p,e ;
SqStack S ;
InitStack(&S);
p=T ;
while(p||!StackEmpty(S))
//遍历左子树
while(p)
(*Visit)(p->data);
Push(&S,p);
p=p->lchild ;
//通过下一次循环中的内嵌while实现右子树遍历
if(!StackEmpty(S))
Pop(&S,&e);
p=e->rchild ;

void InOrderTraverse(BSTree T,Status(*Visit)(ElemType e))
/* 初始条件: 二叉树T存在,Visit是对结点操作的应用函数 */
/* 操作结果: 中序递归遍历T,对每个结点调用函数Visit一次且仅一次 */
if(T)
InOrderTraverse(T->lchild,(*Visit));
/* 先中序遍历左子树 */
(*Visit)(T->data);
/* 再访问根结点 */
InOrderTraverse(T->rchild,(*Visit));
/* 最后中序遍历右子树 */

void PostOrderTraverse(BSTree T,Status(*Visit)(ElemType e))
/* 初始条件: 二叉树T存在,Visit是对结点操作的应用函数 */
/* 操作结果: 后序递归遍历T,对每个结点调用函数Visit一次且仅一次 */
/* T不空 */
if(T)
PostOrderTraverse(T->lchild,(*Visit));
/* 先后序遍历左子树 */
PostOrderTraverse(T->rchild,(*Visit));
/* 再后序遍历右子树 */
(*Visit)(T->data);
/* 最后访问根结点 */

/*输出元素*/
Status PrintElement(ElemType e)
printf(FORMAT,e);
return OK ;

#include"RandomHundred.c"
//功能模块1－void RandomHundred(int ran[100]);产生100个不大于100且各不相同的整数，存放在ran[100]中
#include"BSTree.h"
//平衡二叉排序树的类型定义
#include"InsertAVL.c"
//功能模块2－Status InsertAVL(BSTree *T,ElemType e,Status *taller);
//平衡二叉排序树T插入元素e,taller为长高标志供递归调用时检查
typedef BSTree SElemType;//这个很重要，定义栈的元素类型为二叉树结点指针BSTree
#include"SqStack.h"
//顺序栈的存储结构
#include"SqStack.c"
//栈的操作:供非递归先序遍历用
#include"Traverse.c"
//功能模块3－void PreOrderTraverse(BSTree T,Status (*Visit)(ElemType e));非递归先序遍历二叉树
//void InOrderTraverse(BSTree T,Status(*Visit)(ElemType e));中序遍历二叉树
//void PostOrderTraverse(BSTree T,Status(*Visit)(ElemType e));后序遍历二叉树
//Status PrintElement(ElemType e);输出元素函数，供遍历调用
main()
//主函数
BSTree T=NULL ;
//注意T必须先置空，非常重要
int i,ran[100];
//i为计数器，ran数组用于存放从RandomHundred函数随机得来的1－100
Status taller ;
//长高与否标志，可以不初始化
printf("数据结构课程设计题目：\n");
printf("1－－利用随机函数产生100个(不大于100且各不相同的)随机整数\n");
printf("2－－用这些整数来生成一棵二叉树\n");
printf("3－－分别对二叉树进行先序遍历，中序遍历和后序遍历输出树中结点元素序列\n");
printf("注意：先序遍历输出要求采用非递归来实现\n\n");
printf("产生100个(不大于100且各不相同的)随机整数：\n");
RandomHundred(ran);
for(i=0;i<100;++i)printf(FORMAT,ran[i]);
printf("\n\n");
for(i=0;i<100;++i)InsertAVL(&T,ran[i],&taller);
printf("已经按以上顺序把这些整数一个一个插入平衡二叉排序树!\n\n");
printf("先序遍历二叉树(采用非递归算法):\n");
PreOrderTraverse(T,PrintElement);
printf("\n");
printf("中序遍历二叉树:\n");
InOrderTraverse(T,PrintElement);
printf("\n");
printf("后序遍历二叉树:\n");
PostOrderTraverse(T,PrintElement);
printf("\n\n");
printf("课程设计题目演示完毕!\n06级统计一班 高翕山 200630980108\n");
getch();
参考技术A 自己将一下两个程序整合一下
/*
作者：
时间：
内容：利用随机函数产生100个(不大于100且各不相同的)随机整数
*/
void main()
int a[100],i;
for(i=0;i<=100;i++)
a[i]=rand() % 100;
printf("%4d",a[i]);
if(i%10==0)printf("\n");

//二叉树处理头文件
//包括二叉树的结构定义,二叉树的创建,遍历算法(递归及非递归),
/*
作者：
时间：
内容：完成二叉树创建,二叉树的前,中,后序遍历(递归)
时间：
内容：
时间：
内容：完成查找二叉树的静,动态查找(非递归)
*/
#include "stdlib.h"

#define MAXNODE 20
#define ISIZE 8
#define NSIZE0 7
#define NSIZE1 8
#define NSIZE2 15
//SHOWCHAR = 1(显示字符) SHOWCHAR = 0(显示数字)
#define SHOWCHAR 1
//二叉树结构体
struct BTNode

int data;
BTNode *rchild;
BTNode *lchild;
;
//非递归二叉树遍堆栈
struct ABTStack

BTNode *ptree;
ABTStack *link;
;
char TreeNodeS[NSIZE0] = 'A','B','C','D','E','F','G';
char PreNode[NSIZE0] = 'A','B','D','E','C','F','G';
char MidNode[NSIZE0] = 'D','B','E','A','C','G','F';
int TreeNodeN0[NSIZE1][2] = 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7;
int TreeNodeN1[NSIZE1][2] = 0,0,4,1,2,2,6,3,1,4,3,5,5,6,7,7;
int TreeNode0[NSIZE1][2] = '0',0,'D',1,'B',2,'F',3,'A',4,'C',5,'E',6,'G',7;
int TreeNode1[NSIZE1][2] = '0',0,'A',1,'B',2,'C',3,'D',4,'E',5,'F',6,'G',7;
int TreeNode2[NSIZE2][2] = '0',0,'A',1,'B',2,'C',3,'D',4,'E',5,'F',6,'G',7,'H',8,'I',9,'J',10,'K',11,'L',12,'M',13,'N',14;
int InsertNode[ISIZE] = -10,-8,-5,-1,0,12,14,16;
//char *prestr = "ABDECFG";
//char *midstr = "DBEACGF";
/*
二叉树创建函数dCreateBranchTree1()<递归算法>
参数描述：
int array[]: 二叉树节点数据域数组
int i: 当前节点的序号
int n: 二叉树节点个数
返回值:
dCreateBranchTree1 = 新建二叉树的根节点指针
备注:
根节点 = array[(i+j)/2];
左子节点 = [array[i],array[(i+j)2-1]]
右子节点 = [array[(i+j)/2+1,array[j]]
*/
BTNode *dCreateBranchTree1(char array[],int i,int n)

BTNode *p; /*二叉树节点*/
if(i>=n)
return(NULL);
p = (BTNode *)malloc(sizeof(BTNode));
p->data = array[i];
p->lchild = dCreateBranchTree1(array,2*i+1,n);
p->rchild = dCreateBranchTree1(array,2*i+2,n);
return(p);

/*
二叉树创建函数dCreateBranchTree2()<递归算法>
参数描述：
int array[]: 二叉树节点数据域数组
int i: 当前节点的序号
int n: 二叉树节点个数
返回值:
dCreateBranchTree2 = 新建二叉树的根节点指针
备注:
根节点 = array[(i+j)/2];
左子节点 = [array[i],array[(i+j)2-1]]
右子节点 = [array[(i+j)/2+1,array[j]]
*/
BTNode *dCreateBranchTree2(char array[],int i,int j)

BTNode *p; /*二叉树节点*/
if(i>j)
return(NULL);
p = (BTNode *)malloc(sizeof(BTNode));
p->data = array[(i+j)/2];
p->lchild = dCreateBranchTree2(array,i,(i+j)/2-1);
p->rchild = dCreateBranchTree2(array,(i+j)/2+1,j);
return(p);

/*
二叉树创建函数dCreateBranchTree3()<非递归算法>
已知二叉树的前,中序遍历序列串,构造对应的二叉树
<编程思想>:
首先,在前序遍历序列中的首元素是二叉树的根节点,接着
,在中序遍历序列中找到此节点,那么在此节点以前的节点必为
其左孩子节点,以后的必为其右孩子节点;
然后,在中序遍历序列中,根节点的左子树和右子树再分别
对应子树前序遍历序列的首字符确定子树的根节点,再由中序
遍历序列中根节点的位置分别确定构成它们的左子树和右子树
的节点;
依次类推,确定二叉树的全部节点,构造出二叉树.
参数描述：
char *pre: 前序遍历序列
char *mid: 中序遍历序列
int n: 遍历序列中节点个数
返回值:
dCreateBranchTree3 = 新建二叉树的根节点指针
*/
BTNode *dCreateBranchTree3(char *pre,char *mid,int n)

BTNode *p;
char *t;
int left;
if(n<=0)
return(NULL);
p = (BTNode *)malloc(sizeof(BTNode));
p->data = *pre;
for(t=mid;t<mid+n;t++)
if(*t==*pre) break; /*在中序遍历序列中查找根节点*/
left = t - mid; /*左子树的节点个数*/
p->lchild = dCreateBranchTree3(pre+1,t,left);
p->rchild = dCreateBranchTree3(pre+1+left,t+1,n-1-left);
return(p);

/*
二叉树创建函数CreateBranchTree()<非递归算法>
参数描述：
int array[]: 二叉树节点数据域数组
int n: 二叉树节点个数
返回值:
CreateBranchTree = 新建二叉树的根节点指针
*/
BTNode *CreateBranchTree(int array[][2],int n)

BTNode *head,*p;
BTNode *NodeAddr[MAXNODE]; //节点地址临时缓冲区
int i,norder,rorder;
head = NULL;
printf("二叉树原始数据<新建顺序>：\t");
for(i=1;i<=n;i++)

p = (BTNode *)malloc(sizeof(BTNode));
if(p==NULL)

printf("\n新建节点时内存溢出！\n");
return(NULL);

else

p->data = array[i][0];
p->lchild = p->rchild = NULL;
norder = array[i][1];
NodeAddr[norder] = p;
if(norder>1)

rorder = norder / 2; /*非根节点:挂接在自己的父节点上*/
if(norder % 2 == 0)
NodeAddr[rorder]->lchild = p;
else
NodeAddr[rorder]->rchild = p;

else
head = p; /*根节点*/
if(SHOWCHAR)
printf("%c ",p->data);
else
printf("%d ",p->data);


return(head);

//------------------------------递归部分------------------------------
/*
二叉树前序遍历函数dpre_Order_Access()<递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void dpre_Order_Access(BTNode *head)

if(head!=NULL)

if(SHOWCHAR)
printf("%c ",head->data);
else
printf("%d ",head->data);
dpre_Order_Access(head->lchild); /*递归遍历左子树*/
dpre_Order_Access(head->rchild); /*递归遍历右子树*/


/*
二叉树中序遍历函数dmid_Order_Access()<递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void dmid_Order_Access(BTNode *head)

if(head!=NULL)

dmid_Order_Access(head->lchild); /*递归遍历左子树*/
if(SHOWCHAR)
printf("%c ",head->data);
else
printf("%d ",head->data);
dmid_Order_Access(head->rchild); /*递归遍历右子树*/


/*
二叉树后序遍历函数dlast_Order_Access()<递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void dlast_Order_Access(BTNode *head)

if(head!=NULL)

dlast_Order_Access(head->lchild); /*递归遍历左子树*/
dlast_Order_Access(head->rchild); /*递归遍历右子树*/
if(SHOWCHAR)
printf("%c ",head->data);
else
printf("%d ",head->data);


//------------------------------递归部分------------------------------
//------------------------------非递归部分------------------------------
/*
二叉树前序遍历函数pre_Order_Access()<非递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void pre_Order_Access(BTNode *head)

BTNode *pt;
ABTStack *ps,*top;
pt = head;
top = NULL;
printf("\n二叉树的前序遍历结果<非递归>：\t");
while(pt!=NULL ||top!=NULL) /*二叉树未遍历完,或堆栈非空*/

while(pt!=NULL)

if(SHOWCHAR)
printf("%c ",pt->data); /*访问根节点*/
else
printf("%d ",pt->data); /*访问根节点*/
ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根节点进栈*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

if(top!=NULL)

pt = top->ptree; /*栈顶节点出栈*/
ps = top;
top = top->link;
free(ps); /*释放栈顶节点空间*/
pt = pt->rchild; /*遍历节点右子树*/



/*
二叉树中序遍历函数mid_Order_Access()<非递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void mid_Order_Access(BTNode *head)

BTNode *pt;
ABTStack *ps,*top;
int counter =1;
pt = head;
top = NULL;
printf("\n二叉树的中序遍历结果<非递归>：\t");
while(pt!=NULL ||top!=NULL) /*二叉树未遍历完,或堆栈非空*/

while(pt!=NULL)

ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根节点进栈*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

if(top!=NULL)

pt = top->ptree; /*栈顶节点出栈*/
ps = top;
top = top->link;
free(ps); /*释放栈顶节点空间*/
if(SHOWCHAR)
printf("%c ",pt->data); /*访问根节点*/
else
printf("%d ",pt->data); /*访问根节点*/
pt = pt->rchild; /*遍历节点右子树*/



/*
二叉树后序遍历函数last_Order_Access()<非递归算法>
参数描述：
BTNode *head: 二叉树的根节点指针
*/
void last_Order_Access(BTNode *head)

BTNode *pt;
ABTStack *ps,*top;
int counter =1;
pt = head;
top = NULL;
printf("\n二叉树的后序遍历结果<非递归>：\t");
while(pt!=NULL ||top!=NULL) /*二叉树未遍历完,或堆栈非空*/

while(pt!=NULL)

ps = (ABTStack *)malloc(sizeof(ABTStack)); /*根节点进栈*/
ps->ptree = pt;
ps->link = top;
top = ps;
pt = pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

if(top!=NULL)

pt = top->ptree; /*栈顶节点出栈*/
ps = top;
top = top->link;
free(ps); /*释放栈顶节点空间*/
printf("%c ",pt->data); /*访问根节点*/
pt = pt->rchild; /*遍历节点右子树*/



/*
二叉查找树静态查找函数static_Search_STree()<非递归算法>
参数描述：
BTNode *head: 二叉查找树的根节点指针
int key: 查找关键码
返回值:
static_Search_STree = 键值为key的节点指针(找到)
static_Search_STree = NULL(没有找到)
*/
BTNode *static_Search_STree(BTNode *head,int key)

while(head!=NULL)

if(head->data == key)

printf("\n数据域=%d\t地址=%d\t\n",head->data,head);
return(head); /*找到*/

if(head->data > key)
head = head->lchild; /*继续沿左子树搜索*/
else
head = head->rchild; /*继续沿右子树搜索*/

return(NULL); /*没有查找*/

/*
二叉查找树动态查找函数dynamic_Search_STree()<非递归算法>
参数描述：
BTNode *head: 二叉查找树的根节点指针
BTNode **parent: 键值为key的节点的父节点指针的指针
BTNode **head: 键值为key的节点指针的指针(找到)或NULL(没有找到)
int key: 查找关键码
注意:
*parent == NULL 且 *p == NULL 没有找到(二叉树为空)
*parent == NULL 且 *p != NULL 找到(找到根节点)
*parent != NULL 且 *p == NULL 没有找到(叶节点)<可在parent后插入节点>
*parent != NULL 且 *p != NULL 找到(中间层节点)
*/
void dynamic_Search_STree(BTNode *head,BTNode **parent,BTNode **p,int key)

*parent = NULL;
*p = head;
while(*p!=NULL)

if((*p)->data == key)
return; /*找到*/
*parent = *p; /*以当前节点为父,继续查找*/
if((*p)->data > key)
*p = (*p)->lchild; /*继续沿左子树搜索*/
else
*p = (*p)->rchild; /*继续沿右子树搜索*/


/*
二叉查找树插入节点函数Insert_Node_STree()<非递归算法>
参数描述：
BTNode *head: 二叉查找树的根节点指针
int key: 查找关键码
返回值:
Insert_Node_STree = 1 插入成功
Insert_Node_STree = 0 插入失败(节点已经存在)
*/
int Insert_Node_STree(BTNode *head,int key)

BTNode *p,*q,*nnode;
dynamic_Search_STree(head,&p,&q,key);
if(q!=NULL)
return(0); /*节点在树中已经存在*/
nnode = (BTNode *)malloc(sizeof(BTNode)); /*新建节点*/
nnode->data = key;
nnode->lchild = nnode->rchild = NULL;
if(p==NULL)
head = p; /*原树为空,新建节点为查找树*/
else

if(p->data > key)
p->lchild = nnode; /*作为左孩子节点*/
else
p->rchild = nnode; /*作为右孩子节点*/

return(1); /*插入成功*/

/*
二叉查找树插入一批节点函数Insert_Batch_Node_STree()<非递归算法>
参数描述：
BTNode *head: 二叉查找树的根节点指针
int array[]: 被插入的数据域数组
int n: 被插入的节点数目
*/
void Insert_Batch_Node_STree(BTNode *head,int array[],int n)

int i;
for(i=0;i<n;i++)

if(!Insert_Node_STree(head,array[i]))
printf("\n插入失败<键值为%d的节点已经存在>！\n",array[i]);


//------------------------------非递归部分------------------------------

参考资料：http://bbs.chinaunix.net/archiver/tid-787995.html