1） 构造一棵BST，构造的过程必须是灵活的，能够根据输入的数据来构造；
2） 遍历BST，包括前序遍历，中序遍历，后序遍历，并且每一种遍历都必须要用递规和非递规的方法实现，总共编写6个函数实现遍历；
3） 动态插入和删除BST，删除共有三种情况，每一种情况都要实现一次；
4） 能够把BST树按照树的层次和次序在屏幕上显示出来，而且对BST的每个操作前后都必须把BST输入到屏幕一次，以区别操作前后的变化；
新手级人物要写这有点困难,求助
有的话贴上来或发我邮箱:piao851230@163.com

我也不会

二叉排序树

2叉排序树应该有的都有了

可以参考下2叉树，除了建树不一样，其他的遍历，删除，都雷同。

....救火呀....有高手会做的嘛

我也想要这个啊，哪位高手帮帮忙啊。。。

一天了,还是写不出来,痛痛痛

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include<math.h>
#include<malloc.h>
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)< (b))
#define LQ(a,b) ((a)<=(b))
#define NULL 0
#define ERROR 0;
#define FALSE 0;
#define TRUE 1;
#define OK 1;
typedef int keytype;
typedef int Status;
typedef int ElemType;
typedef struct BiTNode
{keytype key;
ElemType data; /*关键字域*/ /*其他域*/
struct BiTNode *lchild, *rchild; /*左 右孩子指针*/
}BiTNode,*BiTree;
typedef struct stack
{ //二叉树结点栈
BiTree data[100];
int flag[100];
int top;
}stack;

typedef struct queue
{ //二叉树结点队列
BiTree data[30];
int front;
int rear;
}queue;

Status SearchBST(BiTree T,keytype key,BiTree f,BiTree *p)
{//在根指针T所指二叉排序树中递归的查找其关键字等于key的数据元素。

if(!T) {*p=f;return FALSE;}
else if EQ(key,T->data){ *p=T;return TRUE;}
else if LT(key,T->data) return(SearchBST(T->lchild,key,T,p));
else return(SearchBST(T->rchild,key,T,p));
}

Status InsertBST(BiTree *T,ElemType e)
{//当二叉排序树T中不存在关键字等于e的数据元素时，插入e并返回TRUE。
BiTree p;
BiTree s;
if(!SearchBST(*T,e,NULL,&p)){
s=(BiTree)malloc(sizeof(BiTNode));
s->data=e;s->lchild=s->rchild=NULL;
if(!p) *T=s;
else if (LT(e,p->data)) p->lchild=s;
else p->rchild=s;
return TRUE;
}
else return FALSE;
}

BiTree CreatBST(BiTree T) /*建立一个有n个节点的二叉排序树算法*/
{
keytype key; /*关键字*/
int i,n;
T=NULL;
printf("请输入节点个数:\n");
scanf("%d",&n);
printf("请输入数据:\n");
for(i=1;i<=n;i++)
{
scanf("%d",&key); /*假定关键字为整型*/
InsertBST(&T,key);
}
return T;
}
void DeleteBST(BiTree T,keytype key) /*二叉排序树中删除一个结点的算法*/
{
BiTree p,q,s;
p=T;
q=NULL; /*p指向待比较的结点，q指向p的前驱结点*/
while(p!=NULL && p->data!=key) /*查找值域为key的结点*/
if(key<p->data)
{
q=p;
p=p->lchild;
}
else
{
q=p;
p=p->rchild;
}
if(p==NULL)
printf("找不到该节点！%d \n",key);
else if(p->lchild==NULL) /*被删结点无左子树*/
{
if(q==NULL) T=p->rchild; /*考虑p为根结点的情况*/
else if(q->lchild==p)
q->lchild=p->rchild; /*p为双亲的左子树*/
else
q->rchild=p->rchild; /*p为双亲的右子树*/
free(p); /*释放p结点*/
}
else if(p->rchild==NULL) /*被删除结点无右子树*/
{
if(q==NULL)
T=p->rchild; /*考虑p为根结点的情况*/
else if(q->rchild==p)
q->rchild=p->lchild; /*p为双亲的左子树*/
else
q->lchild=p->lchild; /*p为双亲的右子树*/
free(p); /*释放P结点*/
}
else /*被删除结点同时有左子树和右子树*/
{ /*查找被删除结点的左子树中的最右结点，即刚好小于key的结点，也即是p的直接前驱*/
s=p->lchild;
while(s->rchild!=NULL) /*寻找p的直接前驱s*/
s=s->rchild;
s->rchild=p->rchild; /*被删除结点的右子树作为直接前驱s的右子树*/
/*被删除结点的左子树根代替被删结点*/
if(q==NULL) /*被删结点是根结点*/
T=p->lchild;
else if(q->lchild==p) /*p为其双亲结点左子树*/
q->lchild=p->lchild;
else /*p为双亲的右子树*/
q->rchild=p->lchild;
free(p);
}
}

/* 按照前序递归遍历二叉树 */
void Preorder1(BiTree T)
{
if(T!=NULL)
{
printf("%d-",T->data);
Preorder1(T->lchild);
Preorder1(T->rchild);
}
}
/* 按照中序递归遍历二叉树 */
void Inorder1(BiTree T)
{
if(T!=NULL)
{
Inorder1(T->lchild);
printf("%d-",T->data);
Inorder1(T->rchild);
}
}
/* 按照后序递归遍历二叉树 */
void Posorder1(BiTree T)
{
if(T!=NULL)
{
Posorder1(T->lchild);
Posorder1(T->rchild);
printf("%d-",T->data);
}
}
/* 按照前序非递归遍历二叉树 */
void Preorder2(BiTree T)
{
BiTree pre=T;
stack s;
s.top=0;
printf("输出前序非递归遍历:");
while(pre||s.top>0)
{
if(pre)
{
printf("%d-",pre->data);
s.data[s.top++]=pre;
pre=pre->lchild;
}
else
{
pre=s.data[--s.top]->rchild;
}
}
printf("\n\n");
}
/* 按照中序非递归遍历二叉树 */
void Inorder2(BiTree T)
{
BiTree pre=T;
stack s;
s.top=0;
printf("输出中序非递归遍历:");
while(pre||s.top>0)
{
if(pre)
{
s.data[s.top++]=pre;
pre=pre->lchild;
}
else
{
pre=s.data[--s.top];
printf("%d-",pre->data);
pre=pre->rchild;
}
}
printf("\n\n");
}
/* 按照后序非递归遍历二叉树 */
void Posorder2(BiTree T)
{
stack s;
s.top=-1;
printf("输出后序非递归遍历:");
while(T!=NULL||s.top!=-1)
{
while(T)
{
s.top++;
s.flag[s.top]=0;
s.data[s.top]=T;
T=T->lchild;

}
while(s.top>=0&&s.flag[s.top]==1)
{
T=s.data[s.top];
printf("%d-",T->data);
s.top--;
}
if(s.top>=0)
{
T=s.data[s.top];
s.flag[s.top]=1;
T=T->rchild;
}
else
{
T=NULL;
}
}
printf("\n\n");
}
/* 按照层次遍历二叉树 */
void Levelorder(BiTree T)
{
queue q;
q.data[0]=T;
q.front=0;q.rear=1;
printf("层次遍历二叉树结果:");
while(q.front<q.rear)
{
if(q.data[q.front])
{
printf("%d-",q.data[q.front]->data);
q.data[q.rear++]=q.data[q.front]->lchild;
q.data[q.rear++]=q.data[q.front]->rchild;
q.front++;
}
else
{
q.front++;
}
}
printf("\n\n");
}
/* 求树的深度 */
void Depth(BiTree T, int i, int &h)
{
if(T)
{
i++;
if(h<i)
h=i;
}
if(T->lchild)
Depth(T->lchild, i, h);
if(T->rchild)
Depth(T->rchild, i, h);
}
/* 用静态链表储存二叉排序树 */
void cuncu(BiTree T, BiTree str[ ], int h)
{
int i;
double t;
t=pow(2,h);//pow为数学函数
str[1]=T;
for(i=2; i<t; i+=2) {
if(str[i/2]) {
str[i]=str[i/2]->lchild;
str[i+1]=str[i/2]->rchild;
}
else str[i]=str[i+1]=NULL;
}
}
/* 显示输出二叉树 */
void displayBST(BiTree T) {
int i,j,h=0,n,a;
double k,interval,begin,m,s;
BiTree str[10000];
if(T) {
Depth(T,0,h);
cuncu(T, str, h);
s=h-2;
a=2;
k=pow(2,h+1)-2;
begin=(k-2)/2;
for(i=1;i<=begin;i++)
printf(" ");
printf("%d\n",str[1]->data);
for(n=1;n<=s;n++)
printf("\n");
for(i=2;i<=h;i++)
{
interval=begin;
begin=(begin-2)/2;
m=pow(2,i-1);
for(n=1;n<=begin;n++)
printf(" ");
for(j=1;j<=m;j++)
{
if(str[a])
printf("%d",str[a]->data);
else printf(" ");
a++;
if(m!=j)
{
for(n=1;n<=interval;n++)
printf(" ");
}
}
printf("\n");
s--;
for(n=1;n<=s; n++)
printf("\n");
}
printf("\n");
}
else printf("空树\n\n");
}

void main()
{
printf("构建一棵二叉排序树！\n");
keytype key,key1;
BiTree p;
p=NULL;
p=CreatBST(p);
displayBST(p);
printf("*******************************************\n");
printf("输出先序递归遍历：\n");
Preorder1(p);
printf("\n");
printf("输出中序递归遍历：\n");
Inorder1(p);
printf("\n");
printf("输出后序递归遍历：\n");
Posorder1(p);
printf("\n");
Preorder2(p);
Inorder2(p);
Posorder2(p);
Levelorder(p);
printf("*******************************************\n");
printf("输入插入的节点关键字的值\n");
scanf("%d",&key);
InsertBST(&p,key);
displayBST(p);
printf("输出先序递归遍历：\n");
Preorder1(p);
printf("\n");
printf("输出中序递归遍历：\n");
Inorder1(p);
printf("\n");
printf("输出后序递归遍历：\n");
Posorder1(p);
printf("\n");
Preorder2(p);
Inorder2(p);
Posorder2(p);
Levelorder(p);
printf("*******************************************\n");
printf("删除节点1：删除一个节点\n");
printf("请输入要删除的节点：");
scanf("%d",&key1);
DeleteBST(p,key1);
displayBST(p);
printf("输出先序递归遍历：\n");
Preorder1(p);
printf("\n");
printf("输出中序递归遍历：\n");
Inorder1(p);
printf("\n");
printf("输出后序递归遍历：\n");
Posorder1(p);
printf("\n");
Preorder2(p);
Inorder2(p);
Posorder2(p);
Levelorder(p);
printf("*******************************************\n");
printf("删除节点2：被删节点无左子树\n");
printf("请输入要删除的节点：");
scanf("%d",&key1);
DeleteBST(p,key1);
displayBST(p);
printf("输出先序递归遍历：\n");
Preorder1(p);
printf("\n");
printf("输出中序递归遍历：\n");
Inorder1(p);
printf("\n");
printf("输出后序递归遍历：\n");
Posorder1(p);
printf("\n");
Preorder2(p);
Inorder2(p);
Posorder2(p);
Levelorder(p);
printf("*******************************************\n");
printf("删除节点3：被删节点无右子树\n");
printf("请输入要删除的节点：");
scanf("%d",&key1);
DeleteBST(p,key1);
displayBST(p);
printf("输出先序递归遍历：\n");
Preorder1(p);
printf("\n");
printf("输出中序递归遍历：\n");
Inorder1(p);
printf("\n");
printf("输出后序递归遍历：\n");
Posorder1(p);
printf("\n");
Preorder2(p);
Inorder2(p);
Posorder2(p);
Levelorder(p);
}

最大限度了,还有很多问题,希望高手指点一下错误改正