二叉查找算法例题c语言

‘壹’ 二叉树c语言算法,急!!!!

清华大学
严蔚敏
的<数据结构里>都有完整的代码,解释的也很清楚
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
typedef
struct
tree
{
struct
tree
*left;
int
date;
struct
tree
*right;
}treenode,*b_tree;
///////插入节点/////////////////////
b_tree
insert(b_tree
root,int
node)
{
b_tree
newnode;
b_tree
currentnode;
b_tree
parentnode;
newnode=(b_tree)malloc(sizeof(treenode));
newnode->date=node;
newnode->right=NULL;
newnode->left=NULL;
if(root==NULL)
return
newnode;
else
{
currentnode=root;
while(currentnode!=NULL)
{
parentnode=currentnode;
if(currentnode->date>node)
currentnode=currentnode->left;
else
currentnode=currentnode->right;
}
if(parentnode->date>node)
parentnode->left=newnode;
else
parentnode->right=newnode;
}
return
root;
}
//////建立树///////////////////
b_tree
creat(int
*date,int
len)
{
b_tree
root=NULL;
int
i;
for(i=0;i<len;i++)
root=insert(root,date[i]);
return
root;
}
//////中序打印////////////////
void
print1(b_tree
root)
{if(root!=NULL)
{
print1(root->left);
printf("%d->",root->date);
print1(root->right);
}
}
//////后序打印////////////////
void
print2(b_tree
root)
{if(root!=NULL)
{
print2(root->left);
print2(root->right);
printf("%d->",root->date);
}
}
//////前序打印////////////////
void
print3(b_tree
root)
{if(root!=NULL)
{
printf("%d->",root->date);
print3(root->left);
print3(root->right);
}
}
//////////在二叉树中查找给定关键字
////////////
b_tree
lookfor(b_tree
root,int
e)
{
b_tree
p1,p2;
if(root!=NULL)
{
if(root->date==e)
return
root;
else
p1=lookfor(root->left,e);
p2=lookfor(root->right,e);
if(p1!=NULL)
return
p1;
else
if(p2!=NULL)
return
p2;
else
return
NULL;
}
else
return
NULL;
}
///////测试函数//////////////////
void
main()
{
b_tree
root=NULL;
int
i,index;
int
value;
int
nodelist[20];
cout<<"输入树的节点，输入0结束\n";
index=0;
cin>>value;
while(value!=0)
{
nodelist[index]=value;
index=index+1;
cin>>value;
}
root=creat(nodelist,index);
printf("\n中序打印\n");
print1(root);
printf("\n后序打印\n");
print2(root);
printf("\n前序打印\n");
print3(root);
printf("\n查找的词：\n");
int
a;
scanf("%d",&a);
b_tree
p3=lookfor(root,a);
if(p3!=NULL)
printf("%d\n",p3->date);
else
printf("没你要找的词");
}

‘贰’ 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，无非是按照遍历规则来的；

根据“中序遍历”的分析，相信先序遍历和后序遍历也可以轻松写出~

‘叁’ C语言实现二叉搜索

这东西很多的这里给你一个#include
#include
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 (ddat) {
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 (adat)
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;
}
//-

‘肆’ 二叉查找树的插入-C语言实现

father有可能是空指针

‘伍’ C语言 二叉树 递归查找算法

你的if(T->data==x)后面的{}里面没有返回，导致不能及时推出
望采纳，谢谢

‘陆’ 数据结构c语言习题。编写一个函数以二叉查找树T和两个有序的关键字 k1,

//创建二叉树的原数组数据:40206010305070
//前序遍历序列:40201030605070
//中序遍历序列:10203040506070
//后序遍历序列:10302050706040
//输入关键字k1,k2的数值:3050
//打印的结果:
//403050
//
//二叉树示意图:
//
//40
///
//2060
////
//10305070

#include"stdio.h"
#include"stdlib.h"
structTree
{
intdata;
structTree*left;
structTree*right;
};
typedefstructTreeTreeNode;
typedefTreeNode*Bitree;

BitreeinsertNode(Bitreeroot,intdata)//插入结点
{
Bitreenewnode;
Bitreecurrent;
Bitreeback;
newnode=(Bitree)malloc(sizeof(TreeNode));
if(newnode==NULL)
{
printf("
动态分配内存出错.
");
exit(1);
}
newnode->data=data;
newnode->left=NULL;
newnode->right=NULL;
if(root==NULL)
{
returnnewnode;
}
else
{
current=root;
while(current!=NULL)
{
back=current;
if(current->data>data)
current=current->left;
else
current=current->right;
}
if(back->data>data)
back->left=newnode;
else
back->right=newnode;
}
returnroot;
}

BitreecreateTree(int*data,intlen)//创建二叉树(非递归)
{
Bitreeroot=NULL;
inti;
for(i=0;i<len;i++)
{
root=insertNode(root,data[i]);
}
returnroot;
}


voidpreOrder(Bitreeptr)//先序遍历(递归法)
{
if(ptr!=NULL)
{
printf("%d",ptr->data);
preOrder(ptr->left);
preOrder(ptr->right);
}
}

voidinOrder(Bitreeptr)//中序遍历(递归法)
{
if(ptr!=NULL)
{
inOrder(ptr->left);
printf("%d",ptr->data);
inOrder(ptr->right);
}
}

voidpostOrder(Bitreeptr)//后序遍历(递归法)
{
if(ptr!=NULL)
{
postOrder(ptr->left);
postOrder(ptr->right);
printf("%d",ptr->data);
}
}
//根据关键字k1和k2,进行区间查找(递归法)
voidbtreeSearch(Bitreeptr,intk1,intk2)
{
if(ptr!=NULL)
{
if(ptr->data<k1&&ptr->data<k2)
{
btreeSearch(ptr->right,k1,k2);
}
elseif(ptr->data==k1&&ptr->data<k2)
{
printf("%d",ptr->data);
btreeSearch(ptr->right,k1,k2);
}
elseif(ptr->data>k1&&ptr->data<k2)
{
printf("%d",ptr->data);
btreeSearch(ptr->left,k1,ptr->data);
btreeSearch(ptr->right,ptr->data,k2);
}
elseif(ptr->data>k1&&ptr->data==k2)
{
printf("%d",ptr->data);
btreeSearch(ptr->left,k1,k2);
}
elseif(ptr->data>k1&&ptr->data>k2)
{
btreeSearch(ptr->left,k1,k2);
}
elseif(ptr->data==k1&&ptr->data==k2)
{
printf("%d",ptr->data);
}
else
{
printf("其它情况,当前节点的数值是%d",ptr->data);
}
}
}

intmain()
{
BitreeT=NULL;//T是二叉查找树
intdata[]={40,20,60,10,30,50,70};
intlen;
inti;
intk1,k2;//关键字k1,k2
inttmp;

len=sizeof(data)/sizeof(int);
printf("创建二叉树的原数组数据:");
for(i=0;i<len;i++)
{
printf("%d",data[i]);
}

T=createTree(data,len);//创建二叉树

printf("
前序遍历序列:");
preOrder(T);
printf("
中序遍历序列:");
inOrder(T);
printf("
后序遍历序列:");
postOrder(T);

printf("
输入关键字k1,k2的数值:");
scanf("%d%d",&k1,&k2);
if(k1>k2)
{
tmp=k1;
k1=k2;
k2=tmp;
}
//根据关键字k1和k2,进行区间查找(递归法)
btreeSearch(T,k1,k2);

printf("
");
return0;
}