十．用C语言实现查找算法 （1）顺序查找；（2）二分查找（折半查找）；（3）二叉排序树；（4）哈希查找

程序名称：Search.cpp
// 程序功能：采用结构化方法设计程序，实现多种查找算法。
// 程序作者：***
// 最后修改日期：2011-3-3
#include"iostream"
#include"stdlib.h"
#include"stdio.h"
#include "malloc.h"
#define MAX 11
using namespace std;
typedef int ElemType ;
//顺序存储结构
typedef  struct {
ElemType *elem;   //数据元素存储空间基址，建表时按实际长度分配，号单元留空
int  length;      //表的长度
} SSTable;

void Create(SSTable *table, int length);
void Destroy(SSTable *table);
int Search_Seq(SSTable *table, ElemType key);
void Traverse(SSTable *table, void (*visit)(ElemType elem));
// 构建顺序表
void Create(SSTable **table, int length)
{
SSTable *t = (SSTable*) malloc(sizeof(SSTable));//分配空间
t->elem=(ElemType*)malloc(sizeof(ElemType)*(length+1));
t->length=length;
*table=t;
}
// 无序表的输入
void FillTable(SSTable *table)
{
ElemType *t=table->elem;
//for循环，输入各个元素
for(int i=0; i<table->length; i++)
{
t++;
scanf("%d", t);//输入元素
getchar();
}
}
// 销毁表
void Destroy(SSTable *table)
{
free(table->elem);//释放元素空间
free(table);//释放表的空间
}
// 打印查找表
void PrintTable(SSTable *table)
{
int i;//定义变量
ElemType *t=table->elem;
for(i=0; i<table->length; i++)//进入循环，依次打印表中元素
{
t++;
printf("%d ", *t);//打印输出
}
printf("\n");
}
//哨兵查找算法
int Search_Seq(SSTable *table, ElemType key)
{
table->elem[0]=key;//设置哨兵
int result=0;  // 找不到时，返回
int i;
for (i=table->length; i>=1;i--)
{
if  (table->elem[i]==key)
{
result=i;
break;
}
}
return result;//返回结果
}

void printSeq()
{
//先设置几个变量
SSTable *table;
int r;
int	n;
ElemType key;
printf("请输入元素个数:");
scanf("%d",&n);//输入元素个数
Create(&table, n);//建立表
printf("请输入");cout<<n;printf("个值：");
FillTable(table);//输入无序表的值
printf("您输入的%d 个值是：\n",n);
PrintTable(table);//打印无序表
printf("请输入关键字的值:");
scanf("%d",&key);
printf("\n");
printf("顺序查找法运行结果如下：\n\n ");
Search_Seq(table,key);//哨兵查找算法
r=Search_Seq(table,key);
if( r>0)
{
printf(" 关键字%d 在表中的位置是：%d\n",key, r);//打印关键字在表中的位置
printf("\n");
}
else  //查找失败
{
printf ("查找失败，表中无此数据。\n\n");
}
}

// 排序算法
void Sort(SSTable *table )
{
int i, j;
ElemType temp;
for (i=table->length; i>=1 ;i--)    // 从前往后找
{
for (j=1; j<i; j++)
{
if(table->elem[j]>table->elem[j+1])
{
temp=table->elem[j];
table->elem[j]=table->elem[j+1];
table->elem[j+1]=temp;
}
}
}
}

// 二分法查找（非递归）
int Search_Bin(SSTable *table, ElemType key)
{
int low=1;
int high=table->length;
int result=0;  // 找不到时，返回

while(low <= high)//low不大于high时
{
int mid=(low+high)/2;
if(table->elem[mid]==key)//如果找到
{
result=mid;
break;
}
else if(key<table->elem[mid])//如果关键字小于mid对应的值
{
high=mid-1;
}
else  //否则的话
{
low=mid+1;
}
}
return result;//返回结果
}

void printBin()
{
//声明变量
SSTable *table;
int r;
int	n;
ElemType key;

printf("请输入元素个数:");
scanf("%d",&n);
Create(&table, n);//建立表
printf("请输入");cout<<n;printf("个值：");
FillTable(table);//输入无序表的值
printf("您输入的%d 个值是：\n",n);
PrintTable(table);//打印无序表
printf("请输入关键字的值:");
scanf("%d",&key);
printf("\n");
Sort(table);//对无序表进行排序
printf("数据排序后的顺序如下：\n\n ");
PrintTable(table);//打印有序表
printf("\n");
printf("二分查找法的运行结果如下：\n\n ");
r=Search_Bin(table,key);//二分（非递归）查找算法
if( r>0)
printf("关键字%d 在表中的位置是：%d\n",key, r);
else
{
printf ("查找失败，表中无此数据。\n\n");
}
}
//二叉排序树
typedef struct BiTnode //定义二叉树节点
{
int data; //节点的值
struct BiTnode *lchild,*rchild;//节点的左孩子，节点的右孩子
}BiTnode,*BiTree;

//查找（根据节点的值查找）返回节点指针
BiTree search_tree(BiTree T,int keyword,BiTree *father)
{
BiTree p;// 临时指针变量
*father = NULL;//先设其父亲节点指向空
p = T;//p赋值为根节点（从根节点开始查找）
while (p && p->data!=keyword)//如果不是p不指向空且未找到相同值的节点
{
*father = p;//先将父亲指向自己（注意：这里传过来的father是二级指针）
if (keyword < p->data)//如果要找的值小于自己的值
p = p->lchild;// 就向自己的左孩子开始找
else
p = p->rchild;//否则向自己的右孩子开始查找
}
return p;//如果找到了则返回节点指针
}
BiTree creat_tree(int count)
{
BiTree T,p;//设置两个临时变量T,p
int i = 1;
while (i <= count)
{
if (i == 1)//如果i=1，说明还是空树
{
p = (BiTnode *)malloc(sizeof(BiTree));//使p指向新分配的节点
if (!p)//分配未成功
return NULL;
T = p;//分配成功,T=p( 这里实际上T就是根节点)
scanf("%d",&p->data);//输入p指向节点的值
p->lchild = p->rchild = NULL;//p的左孩子和右孩子都指向空
i++;
}
else
{
int temp;// 如果不是空树
scanf("%d",&temp);//输入节点的值
search_tree(T,temp,&p);//查找节点要插入的位置。（T是根节点，插入的节点的值，父亲节点的地址）
if (temp < p->data)//如果插入的值小于父亲节点的值
{
p->lchild = (BiTnode *)malloc(sizeof(BiTnode));//那么就为父亲节点的左孩子分配一个节点空间，并指向这个空间
if (!p->lchild)
return NULL;
p = p->lchild;//分配成功，p指向自己的左孩子
}
else// 如果插入的值大于父亲节点的值
{
p->rchild = (BiTnode *)malloc(sizeof(BiTnode));
if (!p->rchild)
return NULL;//分配不成功，退出
p = p->rchild;//p指向自己的右孩子
}
p -> data = temp;//新分配的节点的值赋值为插入的值
p -> lchild = p->rchild = NULL;//使其左右节点均为NULL
i++;
}
}
return T;//返回根节点
}

void InOrder(BiTree T)
{
if(T)
{
InOrder(T->lchild);
printf("%d ",T->data);
InOrder(T->rchild);
}
}

int insert_tree(BiTree *T,int elem)//插入（根节点，插入的值）返回-1和,-1代表插入失败，代表成功
{
BiTree s,p,father;
s = (BiTnode *)malloc(sizeof(BiTnode));//s指向新开辟一个节点
if (!s)//为开辟成功
return -1;// 返回值-1
s->data = elem;//新节点的值赋值为插入的值
s->lchild = s->rchild = NULL;//其左右孩子为空
p = search_tree(*T,elem,&father);//p赋值为要插入的节点
if (!p)
return -1;//未开辟成功，返回-1
if (father == NULL)//如果父亲节点指向空，说明是空树
*T = s;//让根节点指向s
else if (elem < father->data)//否则如果插入的值小于父亲的值
father->lchild = s;//父亲的左孩子赋值为s
else
father->rchild = s;//否则父亲的右孩子赋值为s
return 0;//返回

}

//删除树结点的操作
int delete_tree(BiTree *T,int elem)
{
BiTree s,p,q,father;//声明变量
p = search_tree(*T,elem,&father);//查找
if(!p)
return -1;
if(!p->lchild)//如果p的左孩子为空
{
if (father == NULL)
{
*T = p->rchild;//T指向左孩子
free(p);//释放p
return 0;
}
if (p == father->lchild)//如果p和father的左孩子相等
father->lchild = p->rchild; //将p的左孩子的值赋给father的左孩子
else
father->rchild = p->rchild;//将p的左孩子的值赋给father的右孩子
free(p);//释放p
return 0;
}
else
if(!p->rchild)
{
if (father == NULL)//如果father为空
{
*T = p->lchild;//将p的左孩子赋给T
free(p);//释放p
return 0;
}
if (p == father->lchild)//如果p等于father的左孩子的值
father->lchild = p->lchild; //将p的左孩子的值赋给father的左孩子
else
father->rchild = p->lchild; //将p的左孩子的值赋给father的右孩子
free(p);
return 0;
}
else
{
q = p;
s = p->lchild;//将p的左孩子赋给s
while (s->rchild)
{
q = s;
s = s->rchild;
}
p->data = s->data;//将s的值赋给p
if (q != p)//如果q不等于p
q->rchild = s->lchild; //将s的左孩子值赋给p的右孩子
else
q->lchild = s->lchild; //将s的左孩子值赋给p的右孩子
free(s);//释放s
return 0;
}
}
//定义print1（）以便调用
void print1()
{
printf("\t**********************\n");
printf("\t1,输出中序遍历\n");
printf("\t2,插入一个结点\n");
printf("\t3,删除一个结点\n");
printf("\t4,查找一个结点\n");
printf("\t5,返回主菜单\n");
printf("\t**********************\n");

}

void printTree()
{
//声明变量
BiTree T,p;
T=NULL;
int	i,n;
ElemType key;
printf("请输入结点个数：\n");
scanf("%d",&n);//输入值
printf("请输入");cout<<n;printf("个值：");
T=creat_tree(n);//建立树
print1();
scanf("%d",&i);//输入各个值
while(i!=5)//i不等于5时
{
switch(i)
{
case 1:
printf("中序遍历二叉树结果如下：\n");
InOrder(T);//中序遍历
break;
case 2:
printf("请输入要插入的结点值：");
scanf("%d",&key);//输入要查找的关键字
if(insert_tree(&T,key))//如果插入成功
printf("插入成功！");
else
printf("已存在此元素！");
break;
case 3:
printf("请输入要删除的结点值：");
scanf("%d",&key); //输入要删除的关键字
if(!(delete_tree(&T,key)))//如果删除成功
printf("删除成功！");
else
printf("不存在此元素！");
break;
case 4:
printf("请输入要查找的结点值：");
scanf("%d",&key); //输入要查找的关键字
if(search_tree(T,key,&p))//如果查找成功
printf("查找成功！");
else
printf("不存在此元素！");
break;
default:
printf("按键错误！");
}
printf("\n");
print1();
scanf("%d",&i);
}
}
//哈希表
typedef struct
{
int num;
}
Elemtype;//定义查找的结点元素
typedef struct
{
Elemtype *elem; //数据元素存储基址
int count; //数据元素个数
int sizeindex;
}HashTable;//定义哈希表

int Hash(int num)
{
int p;
p=num%11;
return p;
}//定义哈希函数

//冲突处理函数，采用二次探测再散列法解决冲突
int collision(int p,int &c)
{
int i,q;
i=c/2+1;
while(i<MAX){
if(c%2==0){
c++;
q=(p+i*i)%MAX;
if(q>=0) return q;
else i=c/2+1;
}
else{
q=(p-i*i)%MAX;
c++;
if(q>=0) return q;
else i=c/2+1;
}
}
return 0;
}

void InitHash(HashTable *H)//创建哈希表
{
int i;
H->elem=(Elemtype *)malloc(MAX*sizeof(Elemtype));
H->count=0;
H->sizeindex=MAX;
for(i=0;i<MAX;i++)
H->elem[i].num=0;//初始化，使SearHash函数能判断到底有没有元素在里面
}

int SearHash(HashTable H,int key,int *p)//查找函数
{
*p=Hash(key);
while(H.elem[*p].num!=key&&H.elem[*p].num!=0)
*p=*p+1;
if(H.elem[*p].num==key)
return 1;
else
return 0;
}

void InsertHash(HashTable *H,Elemtype e)
{//如果查找不到就插入元素
int p;
SearHash(*H,e.num,&p); //查找
H->elem[p]=e;
++H->count;
}

void printHash()//调用哈希表
{
HashTable H;
int p,key,i,n;
Elemtype e;
InitHash(&H);
printf("输入数据个数(<11 ):");
scanf("%d",&n);
printf("请输入各个值：");
for(i=0;i<n;i++)
{//输入n个元素
scanf("%d",&e.num);//输入数字
if(!SearHash(H,e.num ,&p))
{
InsertHash(&H,e );//插入元素
}
else
printf("已经存在\n");//否则就表示元素的数字已经存在
}
printf("输入查找的数字:");
scanf("%d",&key);//输入要查找的数字
if(SearHash(H,key,&p))//能查找成功
{
printf("查找成功！");//输出位置
}
else
printf(" 不存在此元素！");
}

void print()
{
printf("\t**********************\n");
printf("\t1,顺序查找\n");
printf("\t2,二分查找\n");
printf("\t3,二叉排序树\n");
printf("\t4,哈希查找\n");
printf("\t5,退出程序\n");
printf("\t**********************\n");
}

// 主函数
int main(int argc, char* argv[])
{
int i;//定义变量

print();
scanf("%d",&i);//输入要数字选择要使用的查找方法
while(i!=5)//i不等于5时
{
switch(i)
{
case 1://i=1时
printf("顺序查找法：\n");
printSeq();//顺序查找法
break;//跳出循环}
case 2:
printf("二分查找法：\n");
printBin();//二分查找法
break; //跳出循环
case 3:
printf("二叉排序树：\n");
printTree();//二叉排序树
break; //跳出循环
case 4:
printf("哈希查找法：\n");
printHash();//哈希查找法
break; //跳出循环
default:
printf("按键错误！");
}
printf("\n");
print();//调用函数print()
scanf("%d",&i);
}
return 0;//返回0
}
（1）首主菜单：首先出现主菜单，通过选择相应数字进行相应功能的实现，如图所示：

图4.2.1 主菜单
（2）通过主菜单按键选择1进入顺序查找功能，输入元素个数，然后输入这几个元素的值，用户再输入需要查询的数字即可得出查找结果，如果查找成功则显示出关键字所在的位置，否则显示“查找失败，表中无此数据”，图4.2.2示：

图4.2.2 顺序查找

（3）通过主菜单按键选择2进入二分查找功能，根据提示输入元素个数，再输入这几个值，然后输入要查找的关键字，系统排序后会显示该关键字在顺序表中的位置，否则显示“查找失败，表中无此数据”，如图4.2.3所示：

图4.2.3 查询功能
（4）a．通过主菜单按键选择3进入二叉排序树功能，首先输入结点个数及结点的值建立二叉排序树，然后便进入一个菜单提示选择二叉排序树的某个功能如图4.2.4a所示：

图4.2.4a 二叉排序树功能菜单
b.中序遍历二叉排序树，如图4.2.4b所示：

图4.2.4b 中序遍历二叉排序树
c.插入一个结点，如图4.2.4c所示：

图4.2.4c二叉排序树插入一个结点
d．删除一个结点，如图4.2.4d所示：

图4.2.4d 二叉排序树删除一个结点
e．查找一个结点，如图4.2.4e所示：

图4.2.4e 二叉排序树查找一个结点
（5）通过主菜单按键选择4进入哈希查找功能，根据提示输入元素个数，再输入这几个值，然后输入要查找的关键字，找到则显示“查找成功！”，否则显示“不存在此元素”，如图4.2.5所示：

图4.2.5 哈希查找法