c語言二叉排序樹查找

1. 用c語言寫二叉排序樹的基本操作要求實現查找插入和刪除運算，統計二叉樹中度為2的結點個數和葉子結點個數

#include<stdio.h>
#include<stdlib.h>
#definemaxNumberLength16
typedefstructnode
{
intdata;
structnode*lchild,*rchild;
}node;
node*create(void);
voidinsert(node*&root,intdata);
voidinOrder(node*root);
voidremove(node*&root,intdata);
voidsubRemove(node*root,node*&now);
boolsearch(node*root,intdata);
voidfindParent(node*root,node*data,node*&parent);
intmain(void)
{
node*root;
intengine=1;
intdata;
printf("輸入元素:");
root=create();
printf("構造完成,中序遍歷:");
inOrder(root);
putchar('
');
while(engine!=0)
{
printf("

1.插入2.刪除3.查找0.退出
輸入操作編號:");
fflush(stdin);
scanf("%d",&engine);
switch(engine)
{
case1:
printf("輸入插入的元素值:");
scanf("%d",&data);
insert(root,data);
printf("插入完成,中序遍歷:");
inOrder(root);
break;
case2:
printf("輸入刪除的元素值:");
scanf("%d",&data);
remove(root,data);
break;
case3:
printf("輸入查找的元素值:");
scanf("%d",&data);
if(search(root,data))
printf("找到該元素，元素值%d
",data);
else
printf("沒有該元素
");
case0:
break;
default:
printf("沒有該選項
");
}
}
return0;
}
node*create(void)//構造
{
charnumToChar[maxNumberLength];
charinch;
intlocation,data;
node*root=NULL;
inch=getchar();
while((inch<'0'||inch>'9')&&inch!='
')
inch=getchar();
while(inch!='
')
{
location=0;
while(inch>='0'&&inch<='9')
{
numToChar[location++]=inch;
inch=getchar();
}
numToChar[location]='';
while((inch<'0'||inch>'9')&&inch!='
')
inch=getchar();
data=atoi(numToChar);
insert(root,data);
}
returnroot;
}
voidinsert(node*&root,intdata)//插入
{
if(root==NULL)
{
root=(node*)malloc(sizeof(node));
root->data=data,root->lchild=root->rchild=NULL;
}
else
{
if(data<=root->data)
insert(root->lchild,data);
else
insert(root->rchild,data);
}
}
voidinOrder(node*root)//中序遍歷
{
if(root!=NULL)
{
inOrder(root->lchild);
printf("%d",root->data);
inOrder(root->rchild);
}

}
voidremove(node*&root,intdata)//刪除
{
if(search(root,data))
{
node*temp=root,*parent;
while(temp)
{
if(temp->data<data)
temp=temp->rchild;
elseif(temp->data>data)
temp=temp->lchild;
else
break;
}
subRemove(root,temp);
printf("刪除成功，中序遍歷:");
inOrder(root);
}
else
printf("沒有該元素
");
}
boolsearch(node*root,intdata)
{
node*temp=root;
while(temp)
{
if(temp->data<data)
temp=temp->rchild;
elseif(temp->data>data)
temp=temp->lchild;
else
break;
}
returntemp;
}
voidfindParent(node*root,node*data,node*&parent)
{
if(root)
{
if(root->lchild==data||root->rchild==data)
parent=root;
else
{
findParent(root->lchild,data,parent);
findParent(root->rchild,data,parent);
}
}
}
voidsubRemove(node*root,node*&now)
{
if(now->lchild==NULL&&now->rchild==NULL)
{
node*parent;
findParent(root,now,parent);
if(parent->lchild==now)
parent->lchild=NULL;
else
parent->rchild=NULL;
free(now);
}
else
{
node*temp=now;
intdata;
if(temp->lchild)
{
temp=temp->lchild;
while(temp->rchild)
temp=temp->rchild;
}
else
{
temp=temp->rchild;
while(temp->lchild)
temp=temp->lchild;
}
data=temp->data,temp->data=now->data,now->data=data;
now=temp;
subRemove(root,now);
}
}

2. 數據結構實驗，求用C語言編一個二叉排序樹的創建和查找的程序

這東西很多的這里給你一個#include <stdio.h>
#include <stdlib.h>
typedef struct np{
int dat;
struct np *left,*right;
} node;
node *create(void)
{
return (malloc(sizeof(node)));
}
node *t(node *a,int d)
{
if (a==NULL) {
a=create();
a->left =a->right =NULL;
a->dat=d;
}
else if (d>=a->dat) {
a->right =t(a->right,d);
}
else if (d<a->dat) {
a->left =t(a->left ,d);
}
return a;
}
void inorder(node *r)
{
if (r!=NULL) {
inorder(r->left );
printf("%d ",r->dat );
inorder(r->right );
}
}
int ser(node *so,int a)
{
if (so==NULL)
return 0;

else if (so->dat==a)
return 1;

else if (a>so->dat)
return ser(so->right,a);

else if (a<so->dat)
return ser(so->left ,a);

}
int main(int argc, char* argv[])
{
node *bst=NULL;
FILE *fp;
int i;
fp=fopen("c:\\dat.txt","r"); /*假設數據文件是c:\dat.txt*/

while (!feof(fp)){
fscanf(fp,"%d",&i);
bst=t(bst,i); /*生成二叉排序樹*/
}
fclose(fp);
inorder(bst); /*輸出二叉排序樹*/
putchar('\n');
scanf("%d",&i); /*輸入需要查找的數字*/
if (ser(bst,i)) printf("YES"); /*如果找到，則輸出yes，否則輸出no*/
else printf("NO");
return 0;
}
//-

3. 二叉排序樹的建立與搜索 【用c語言編寫的完整程序，包括main()函數】

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct tree
{
char data;
tree *lchild,*rchild;
tree *father;
};

tree *Creat(tree *root,char p)
{
if(root==NULL)
{
root=(tree *)malloc(sizeof(tree));
root->lchild=NULL;
root->rchild=NULL;
root->father=NULL;
root->data = p;
}
else
{
if(root->data>=p)
{
root->lchild=Creat(root->lchild,p);
root->father = root->lchild;
}
else {
root->rchild=Creat(root->rchild,p);
root->father = root->rchild;
}
}
return root;
}

void PreOrderTraverse(tree *root)
{
if(root!=NULL)
{
PreOrderTraverse(root->lchild);
printf("%c ", root->data);
PreOrderTraverse(root->rchild);
}
}

void InOrderTraverse(tree *root) {
if ( root != NULL ) {
printf("%c ", root->data);
InOrderTraverse(root->lchild);
InOrderTraverse(root->rchild);
}
}

void PostOrderTraverse(tree *root) {
if ( root != NULL ) {
PostOrderTraverse(root->lchild);
PostOrderTraverse(root->rchild);
printf("%c ", root->data);
}
}

int main()
{
tree *root=NULL;
char p;
while( p = getchar() )
{
if ( p == ' ' || p == '\n' ) continue;
if ( p == '#' ) break;
root=Creat(root,p);
}
printf("先序： ");
InOrderTraverse(root);// 先序
printf("\n");
printf("中序： ");
PreOrderTraverse(root); // 中序
printf("\n後序： ");
PostOrderTraverse(root);// 後序
return 0;
}

4. 二叉排序樹的實現（c語言）

/*二叉樹的基本運算與實現*/
#include <stdio.h>
#include <malloc.h>
#define MAXNODE 256
typedef int datatype;
typedef struct BiTNode
{
datatype data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef struct
{
BiTree link;
int flag;
}stacktype;void menu();
int Initiate(BiTree *bt,datatype x);
BiTree InsertL(BiTree bt,datatype x,BiTree parent);
BiTree InsertR(BiTree bt,datatype x,BiTree parent);
BiTree DeleteL(BiTree bt,BiTree parent);
BiTree DeleteR(BiTree bt,BiTree parent);
void PreOrder(BiTree bt);
void InOrder(BiTree bt);
void PostOrder(BiTree bt);
void LevelOrder(BiTree bt);
BiTree Find(BiTree parent,datatype a);
void NRPreOrder(BiTree bt);
void NRInOrder(BiTree bt);
void NRPostOrder(BiTree bt);void main()
{
int n,m=1;
BiTree t; /*clrscr();*/
while(m)
{
menu();
scanf("%d",&n);
switch(n)
{
case 1:{/*初始化*/
int flag;
datatype x;
printf("please input head point x:\n");
scanf("%d",&x);
flag=Initiate(&t,x);
if(flag==1)
printf("\nInitiate success!");
else
printf("\nInitiate fail!");
break;
}
case 2:{/*建樹*/
break;
}
case 3:{/*插入結點x作為a的左孩子*/
datatype a,x;/*x作為a的左孩子*/
BiTree parent=t;
printf("please input a and x:\n");
scanf("%d%d",&a,&x);
parent=Find(parent,a);
parent=InsertL(t,x,parent);
if(parent!=NULL)
t=parent;
break;
}
case 4:{/*插入結點x作為a的右孩子*/
datatype a,x;/*x作為a的右孩子*/
BiTree parent=t;
printf("please input a and x:\n");
scanf("%d%d",&a,&x);
parent=Find(parent,a);
parent=InsertR(t,x,parent);
if(parent!=NULL)
t=parent;
break;
}
case 5:{/*刪除結點a的左孩子*/
datatype a;
BiTree parent=t;
printf("please input a:\n");
scanf("%d",&a);
parent=Find(parent,a);
parent=DeleteL(t,parent);
if(parent!=NULL)
t=parent;
break;
}
case 6:{/*刪除結點a的左孩子*/
datatype a;
BiTree parent=t;
printf("please input a:\n");
scanf("%d",&a);
parent=Find(parent,a);
parent=DeleteR(t,parent);
if(parent!=NULL)
t=parent;
break;
}
case 7:{/*遞歸先序遍歷*/
PreOrder(t);
break;
}
case 8:{/*遞歸中序遍歷*/
InOrder(t);
break;
}
case 9:{/*遞歸後序遍歷*/
PostOrder(t);
break;
}
case 10:{/*層次遍歷*/
LevelOrder(t);
break;
}
case 11:{/*先序遍歷的非遞歸實現*/
NRPreOrder(t);
break;
}
case 12:{/*中序遍歷的非遞歸實現*/
NRInOrder(t);
break;
}
case 13:{/*後序遍歷的非遞歸實現*/
NRPostOrder(t);
break;
}
case 0:m=0;
}
}
}
void menu()
{
/*clrscr();*/
printf("\n");
printf("\t\t1.initiate\n\n");
printf("\t\t2.create thread\n\n");
printf("\t\t3.insert Left\n\n");
printf("\t\t4.insert Right\n\n");
printf("\t\t5.delete Left\n\n");
printf("\t\t6.delete Right\n\n");
printf("\t\t7.preorder\n\n");
printf("\t\t8.inorder\n\n");
printf("\t\t9.postorder\n\n");
printf("\t\t10.levelorder\n\n");
printf("\t\t11.nrpreorder\n\n");
printf("\t\t12.nrinorder\n\n");
printf("\t\t13.nrpostorder\n\n");
printf("\t\t0.exit\n\n");
printf("\n\n\n\tplease select:");
}
int Initiate(BiTree *bt,datatype x)
{
if((*bt=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
return 0;
(*bt)->data=x;
(*bt)->lchild=NULL;
(*bt)->rchild=NULL;
return 1;
}
BiTree InsertL(BiTree bt,datatype x,BiTree parent)
{
BiTree p;
if(parent==NULL)
{
printf("\nerror!\n");
return NULL;
}
if((p=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
return NULL;
p->data=x;
p->lchild=NULL;
p->rchild=NULL;
if(parent->lchild==NULL)
parent->lchild=p;
else
{
p->lchild=parent->lchild;
parent->lchild=p;
}
return bt;
}
BiTree InsertR(BiTree bt,datatype x,BiTree parent)
{
BiTree p;
if(parent==NULL)
{
printf("\nerror!\n");
return NULL;
}
if((p=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
return NULL;
p->data=x;
p->lchild=NULL;
p->rchild=NULL;
if(parent->rchild==NULL)
parent->rchild=p;
else
{
p->rchild=parent->rchild;
parent->rchild=p;
}
return bt;
}
BiTree DeleteL(BiTree bt,BiTree parent)
{
BiTree p;
if(parent==NULL||parent->lchild==NULL)
{
printf("\ndelete error!");
return NULL;
}
p=parent->lchild;
parent->lchild=NULL;
free(p);
return bt;
}
BiTree DeleteR(BiTree bt,BiTree parent)
{
BiTree p;
if(parent==NULL||parent->rchild==NULL)
{
printf("\ndelete error!");
return NULL;
}
p=parent->rchild;
parent->rchild=NULL;
free(p);
return bt;
}
void PreOrder(BiTree bt)
{
if(bt==NULL)
return;
printf("%5d",bt->data);
PreOrder(bt->lchild);
PreOrder(bt->rchild);
}
void InOrder(BiTree bt)
{
if(bt==NULL)
return;
InOrder(bt->lchild);
printf("%5d",bt->data);
InOrder(bt->rchild);
}
void PostOrder(BiTree bt)
{
if(bt==NULL)
return;
PostOrder(bt->lchild);
PostOrder(bt->rchild);
printf("%5d",bt->data);
}
void LevelOrder(BiTree bt)
{
BiTree Queue[MAXNODE];
int front,rear;
if(bt==NULL)
{
return;
}
front = -1;
rear = 0;
Queue[rear] = bt;
while(front!=rear)
{
front++;
printf("%5d",Queue[front]->data);
if(Queue[front]->lchild!=NULL)
{
rear++;
Queue[rear]=Queue[front]->lchild;
}
if(Queue[front]->rchild!=NULL)
{
rear++;
Queue[rear]=Queue[front]->rchild;
}
}//end while
}
BiTree Find(BiTree parent,datatype a)
{
BiTree p;
if(parent==NULL)
p=NULL;
else if(parent->data==a)
p=parent;
else
{
p=Find(parent->lchild,a);
if(p==NULL)
p=Find(parent->rchild,a);
}
return p;
}
void NRPreOrder(BiTree bt)
{
BiTree stack[MAXNODE],p;
int top;
if(bt==NULL)
{
printf("Tree is empty!\n");
return;
}
top=-1;
p=bt;
while((p!=NULL)||(top!=-1))
{
while(p!=NULL)
{
printf("%5d",p->data);
if(top==MAXNODE-1)
{
printf("Stack overflow!\n");
return;
} /* end if */
else
{
top++;
stack[top]=p;
} /* end if-else */
p=p->lchild;
} /* end while p */
p=stack[top];
top--;
p=p->rchild;
} /* end while p && top */
}
void NRInOrder(BiTree bt)
{
BiTree stack[MAXNODE],p;
int top;
if(bt==NULL)
{
printf("Tree is empty!\n");
return;
}
top=-1;
p=bt;
while((p!=NULL)||(top!=-1))
{
while(p!=NULL)
{
if(top==MAXNODE-1)
{
printf("Stack overflow!\n");
return;
} /* end if */
else
{
top++;
stack[top]=p;
} /* end if-else */
p=p->lchild;
} /* end while p */
p=stack[top];
top--;
printf("%5d",p->data);
p=p->rchild;
} /* end while p && top */
}
void NRPostOrder(BiTree bt)
{
stacktype stack[MAXNODE];
BiTree p;
int top,sign;
if(bt==NULL)
{
printf("Tree is empty!\n");
return;
}
top=-1;
p=bt;
while((p!=NULL)||(top!=-1))
{
if(p!=NULL) /*結點第一次入棧*/
{
top++;
stack[top].link=p;
stack[top].flag=1; /*標記第一次入棧*/
p=p->lchild;
} /* end if */
else
{
p=stack[top].link;
sign=stack[top].flag;
top--;
if(sign==1) /*結點第二次入棧*/
{
top++;
stack[top].link=p;
stack[top].flag=2; /*標記第二次入棧*/
p=p->rchild;
} /* end if */
else
{
printf("%5d",p->data);
p=NULL;
} /* end if-else */
} /* end if-else */
} /* end while */
}

5. 二叉排序樹的查找（C語言）代碼

#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#define INFMT "%d"
#define OUTFMT "%d "
/* #define NULL 0L */
#define BOOL int
#define TRUE 1
#define FALSE 0
#define LEN 10000

typedef int ElemType;
typedef struct BSTNode
{
ElemType data;
struct BSTNode *lchild, *rchild;
} BSTNode, *BSTree;

/* 插入新節點 */
void Insert(BSTree *tree, ElemType item)
{
BSTree node = (BSTree)malloc(sizeof(BSTNode));
node->data = item;
node->lchild = node->rchild = NULL;

if (!*tree)
*tree = node;
else
{
BSTree cursor = *tree;

while (1)
{
if (item < cursor->data)
{
if (NULL == cursor->lchild)
{
cursor->lchild = node;
break;
}

cursor = cursor->lchild;
}
else
{
if (NULL == cursor->rchild)
{
cursor->rchild = node;
break;
}

cursor = cursor->rchild;
}
}
}
return;
}

/* 查找指定值 */
BSTree Search(BSTree tree, ElemType item)
{
BSTree cursor = tree;

while (cursor)
{
if (item == cursor->data)
return cursor;
else if ( item < cursor->data)
cursor = cursor->lchild;
else
cursor = cursor->rchild;
}

return NULL;
}

/* 中綴遍歷 */
void Inorder(BSTree tree)
{
BSTree cursor = tree;

if (cursor)
{
Inorder(cursor->lchild);
printf(OUTFMT, cursor->data);
Inorder(cursor->rchild);
}
}

/* 回收資源 */
void Cleanup(BSTree tree)
{
BSTree cursor = tree, temp = NULL;

if (cursor)
{
Cleanup(cursor->lchild);
Cleanup(cursor->rchild);
free(cursor);
}
}

/* 產生一組隨機數 */
void randnum(int *a, int s)
{
int i, j, mod = s * 10;
srand(time(NULL));

for (i = 0; i < s; ++i)
{
a[i] = rand() % mod + 1;

for (j = 0; j < i; ++j)
{
if (a[i] == a[j])
{
a[i] = rand() % mod + 1;
j = -1;
continue;
}
}
}
}

void main()
{
ElemType item;
char choice;
BSTree root = NULL, ret; /* 必須賦予NULL值，否則出錯 */
BOOL finish = FALSE;

printf("***歡迎使用二叉排序樹演示程序***\n\n");
printf("請選擇創建樹的方式：\n");
printf("1. 手動輸入數據創建二叉排序樹\n");
printf("2. 自動產生數據創建二叉排序樹\n");

do
{
scanf("%c", &choice);
getchar();

if (choice == '1' || choice == '2')
finish = TRUE;

} while (FALSE == finish);

switch (choice)
{
case '1':
{
printf("請輸入數據(-10000結束)：\n");

while (1)
{
scanf(INFMT, &item);

if (-10000 != item)
Insert(&root, item);
else
break;
}
break;
}
case '2':
{
int ia[LEN], i = 0, loop = LEN;
randnum(ia, LEN);

while (loop--)
{
Insert(&root, ia[i++]);
}

break;
}
}

printf("\n\n創建完成...\n");
Inorder(root);
printf("\n\n");

/* 二叉排序樹的查找測試 */
do
{
printf("\n請輸入查找數據：");
scanf("%d", &item);
getchar();
printf("Searching...\n");
ret = Search(root, item);

if (NULL == ret)
printf("查找失敗！");
else
printf("查找成功！");

printf("\n繼續測試按y，退出按其它鍵。\n");
choice = getchar();
} while (choice=='y'||choice=='Y');

Cleanup(root);
}

6. C語言二叉樹遍歷查找問題

二叉樹的遍歷分為以下三種：

先序遍歷：遍歷順序規則為【根左右】

中序遍歷：遍歷順序規則為【左根右】

後序遍歷：遍歷順序規則為【左右根】

什麼是【根左右】？就是先遍歷根，再遍歷左孩子，最後遍歷右孩子；

舉個例子，看下圖：

先序遍歷：ABCDEFGHK

中序遍歷：BDCAEHGKF

後序遍歷：DCBHKGFEA

以中序遍歷為例：

中序遍歷的規則是【左根右】，我們從root節點A看起；

此時A是根節點，遍歷A的左子樹；

A的左子樹存在，找到B，此時B看做根節點，遍歷B的左子樹；

B的左子樹不存在，返回B，根據【左根右】的遍歷規則，記錄B，遍歷B的右子樹；

B的右子樹存在，找到C，此時C看做根節點，遍歷C的左子樹；

C的左子樹存在，找到D，由於D是葉子節點，無左子樹，記錄D，無右子樹，返回C，根據【左根右】的遍歷規則，記錄C，遍歷C的右子樹；

C的右子樹不存在，返回B，B的右子樹遍歷完，返回A；

至此，A的左子樹遍歷完畢，根據【左根右】的遍歷規則，記錄A，遍歷A的右子樹；

A的右子樹存在，找到E，此時E看做根節點，遍歷E的左子樹；

E的左子樹不存在，返回E，根據【左根右】的遍歷規則，記錄E，遍歷E的右子樹；

E的右子樹存在，找到F，此時F看做根節點，遍歷F的左子樹；

F的左子樹存在，找到G，此時G看做根節點，遍歷G的左子樹；

G的左子樹存在，找到H，由於H是葉子節點，無左子樹，記錄H，無右子樹，返回G，根據【左根右】的遍歷規則，記錄G，遍歷G的右子樹；

G的右子樹存在，找到K，由於K是葉子節點，無左子樹，記錄K，無右子樹，返回G，根據【左根右】的遍歷規則，記錄F，遍歷F的右子樹；

F的右子樹不存在，返回F，E的右子樹遍歷完畢，返回A；

至此，A的右子樹也遍歷完畢；

最終我們得到上圖的中序遍歷為BDCAEHGKF，無非是按照遍歷規則來的；

根據「中序遍歷」的分析，相信先序遍歷和後序遍歷也可以輕松寫出~

7. c語言 二叉排序樹 100分

class TREE
{
private:
NODE *root; //樹根
ofstream outfile; //輸出流
public:
TREE(){root=0;} //構造函數，用來初始化樹根
~TREE(){} //析構函數
void build_tree(NODE *&root,long data,float number); //建立二叉樹
int search_tree(NODE *root,float number); //搜索二叉樹
void print(NODE *root,ofstream outfile); //輸出
void destory(NODE *root); //刪除root

};

//建立二叉樹
void TREE::build_tree(NODE *&root,long data,float number)
{
NODE *temp,*backtemp; //定義當前指針和拖後指針
if(root==0) //定義樹根
{
root=new NODE;
root->lchild=root->rchild=0;
root->data=data;
root->number=number;
}
else
{
temp=root;
while(temp!=0)
{
backtemp=temp;
if(number>(temp->number))
temp=temp->lchild;
else temp=temp->rchild;
}

if(number>(backtemp->number))
{
NODE *newdode = new NODE;
newdode->lchild=newdode->rchild=0;
newdode->data=data;
newdode->number=number;
backtemp->lchild=newdode;
}
else
{
NODE *newdode = new NODE;
newdode->lchild=newdode->rchild=0;
newdode->data=data;
newdode->number=number;
backtemp->rchild=newdode;
}
}
}

//輸出二叉樹，按照中序遍歷
void TREE::print(NODE *root,ofstream outfile)
{
if(root!=0)
{
print(root->lchild,outfile);
outfile << (root->data) << " ";
outfile << (root->number) << endl;
print(root->rchild,outfile);

}
}

void TREE::destory(NODE *root)

8. C程序 二叉排序樹的創建和查找 問題

/* 初始化二叉樹，即把樹根指針置空 */
void InitBiTree(BiTree &T){
T=NULL;
}

/* 按先序次序建立一個二叉樹*/
Status PreCreatBiTree(BiTree &T){
ElemType ch;
cin>>ch;
if (ch=='#') T = NULL;
else {
if (!(T = (BitNode *)malloc(sizeof(BitNode))))
return ERROR;
T->data = ch; // 生成根結點
PreCreatBiTree(T->lchild); // 構造左子樹
PreCreatBiTree(T->rchild); // 構造右子樹
}
return OK;
}
/* 按中序次序建立一個二叉樹*/
Status InCreatBiTree(BiTree &T){
ElemType ch;
cin>>ch;
if (ch=='#') T = NULL;
else {
if (!(T = (BitNode *)malloc(sizeof(BitNode))))
return ERROR;
InCreatBiTree(T->lchild); // 構造左子樹
T->data = ch;
InCreatBiTree(T->rchild); // 構造右子樹
}
return OK;
}

9. C語言數據結構（二叉排序樹的創建及查找演算法）

int BSTInsert(BTNode *&T,int k)//修改此處，理由：引用型操作