代码-查找

#include <stdio.h>
//#include <string.h>
#include <stdlib.h>
typedef int KeyType;
#define MAX 100
typedef struct {
    KeyType key;
}RecType;/*查找表中记录类型*/

typedef struct tnode
{  int data;
    struct tnode *lchild, *rchild;
}TNODE;
typedef struct Node{
    int data;
    int Length;
    struct Node *next;
}HNode;
HNode **HA;
TNODE *root=NULL;
int pre=0,flag=1;
int last=0;
 typedef struct hash
{
    int *data;
    int Length;
    int num;
}hstable;
typedef struct BiNode
{//树
    int data;
    struct BiNode * lchild ,* rchild;
}BiNode ,*BiTree;
int seqsearch(RecType ST[],int n,KeyType k)//顺序查找
{
    int i;
    for (i = 0; i < n; i++) { //从第 1 个元素开始遍历
        if (ST[i].key == k) { //匹配成功，返回元素所处的位置下标
            return i;
        }
    }
    return 0; //匹配失败，返回0
}

int BinSearch (RecType R[],int n,KeyType k)/*折半查找*/
{
    int low = 1 , high = n , mid ;
/* int count = 0 ;*/
    while (low <= high)
    {
        mid = (low + high)/2 ;
        if (R[mid].key == k)
            return mid;
        if (R[mid].key > k)
            high = mid - 1 ;
        else
            low = mid + 1 ;
    }
    return 0;
}

void insert(int m){//向二叉排序树中插入数据
    TNODE *p1,*p2;
    if(root==NULL)
    {
        root=(TNODE *)malloc(sizeof(TNODE));
        root->data=m;
        root->lchild=root->rchild=NULL;
    }
    else
    {
        p1=root;
        while(m!=p1->data){
            if((m<p1->data)&&(p1->lchild!=NULL))
                p1=p1->lchild;
            else if((m>p1->data)&&(p1->rchild!=NULL))
                p1=p1->rchild;
            else if((m<p1->data)&&(p1->lchild==NULL)){
                p2=(TNODE *)malloc(sizeof(TNODE));
                p2->data=m;
                p2->lchild=p2->rchild=NULL;
                p1->lchild=p2;
                return;
            }
            else if((m>p1->data)&&(p1->rchild==NULL))
            {
                p2=(TNODE *)malloc(sizeof(TNODE));
                p2->data=m;
                p2->lchild=p2->rchild=NULL;
                p1->rchild=p2;
                return;
            }
        }
    }
}

void createtree()//创建二叉排序
{   int n;
    int k;
    printf("请输入二叉排序树中的关键字个数:\n");
    scanf("%d",&n);
    printf("请依次输入二叉排序树中的关键字:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d",&k);
        insert(k);
    }
}

void find_tree(int m)//二叉排序查找
{
    TNODE *p1;
    if(root==NULL){
        printf("该二叉树为空树，查找不成功，插入%d\n",m);
        insert(m);
    }
    else{
        p1=root;
        while (m!=p1->data){
            if((m<p1->data)&&(p1->lchild!=NULL))
                p1=p1->lchild;
            else if((m>p1->data)&&(p1->rchild!=NULL))
                p1=p1->rchild;
            else
            {
                printf("查找不成功，执行插入操作\n");
                insert(m);
            }
        }
    }
    printf("查找成功!\n");
    return;
}

int initHash(hstable *La) {//生成空的哈希表
    int i;
    La->data = (int *) malloc(MAX * sizeof(int));//分配La的存储空间
    printf("请输入哈希表的表长length和元素个数num\n");
    printf("表长length=");
    scanf("%d", &La->Length);
    printf(" 元素个数num=");
    scanf("%d", &La->num);
    if (La->Length < La->num) //哈希表中关键字的个数不能大于当前表的空间长度
    {
        printf("哈希表的关键字个数大于表长,哈希表初始化失败\n");
        return 0;
    } else {
        int *p = La->data;
        for (i = 0; i < La->Length; i++)
            *(p + i) = 0; //初始化时，每个哈希地址的值都设置成0
        return 1;
    }
}
int Hash(int k,int p){
    int h;
    h=k%p;
    return h;
}
int HashSearch(hstable *ht,int K,int p){
    int h0,di=0,hi;
    h0=Hash(K,p);
    hi=h0;
    while(di<ht->Length&&ht->data[hi]!=0){
        hi=(h0+di)%ht->Length;
        if(ht->data[hi]==K)
            return 1;
        else
            di=di+1;
    }
    return 0;
}


void creatHashTable(hstable *La,int p){
    int i,j,K,h0,h1,di,num;
    int h[MAX];
    printf("请输入哈希表的%d个关键字:",La->num);
    for (i = 0; i <La->num ; i++)
        scanf("%d",&h[i]);
    num=La->num;
    printf("\n");
    for (i = 0; i < num; i++) {
        K=h[i];
        j=HashSearch(La,K,p);
        if(j==1){
            printf("输入序列中关键字%d有重复，元素个数num减1\n",K);
            La->num=La->num-1;
        }
        if(j==0){
            h0=K%p;
            for ( di = 0; di < La->Length; di++) {
                h1=(h0+di)%La->Length;
                if(La->data[h1]==0){
                    La->data[h1]=K;
                    break;
                }
            }
        }
    }
}


BiTree CreateBiTree(BiTree bt)
{       int ch;
    BiTree h=NULL;
    scanf("%d",&ch);
    //ch=getch();
    if(ch==0) bt=NULL;
    else
    {
        if((bt=(BiNode *)malloc(sizeof(BiNode)))==NULL)
            return NULL;
        bt->data=ch;
        printf("构造%d的左子树\n",ch);
        bt->lchild=CreateBiTree(h);
        printf("构造%d的右子树\n",ch);
        bt->rchild=CreateBiTree(h);
    }
    return(bt);
}

int Is_BSTree(BiTree T){
if(T->lchild&&flag) Is_BSTree(T->lchild);
if(T->data<pre) flag=0;
pre=T->data;
if(T->rchild&&flag) Is_BSTree(T->rchild);
return flag;
}

void findMaxMin(int aim, TNODE *ptr)
{
    if(ptr!=NULL)
    {
        findMaxMin(aim, ptr->lchild);
        if(last<aim && ptr->data>=aim)       //找到小于aim的最大元素
            printf("小于%d的最大元素为%d\n",aim,last);
        if(last<=aim && ptr->data>aim)       //找到大于aim的最小元素
            printf("大于%d的最小元素为%d\n",aim,ptr->data);
        last=ptr->data;
        findMaxMin(aim, ptr->rchild);
    }
}

void InitHash(int length){
    int i;
    for ( i = 0; i < length; i++) {
        HA[i]=(HNode *) malloc(sizeof (HNode));
        HA[i]->data=i;
        HA[i]->next=NULL;
    }
}

int SearchHash(HNode **Q,int k,int length){
    int key;
    HNode *p;
    key=k%length;
    if(Q[key]->next==NULL)
        return 0;
    else
    {
        p=Q[key]->next;
        while (p!=NULL)
        {
            if(p->data==k)
                return 1;
            p=p->next;
        }
        return 0;
    }
}

void prtLH(HNode **Q,int m){
    HNode *p;
    for (int i = 0; i < m; i++) {
        p=Q[i]->next;
        printf("第%d个链表",i);
        while (p!=NULL){
            printf("->%d",p->data);
          //  fflush(stdin);
            p=p->next;
        }
        printf("\n");
    }
}

void InsertHash(HNode **Q,int k,int length){
    int key;
    HNode *p,*q;
    key=k%length;
    if(Q[key]->next!=NULL){
        p=Q[key]->next;
        while(p->next!=NULL)
            p=p->next;
        q=(HNode *) malloc(sizeof (HNode));
        q->data=k;
        q->next=NULL;
        p->next=q;
    }
    else
    {
        q=(HNode *) malloc(sizeof (HNode));
        q->data=k;
        q->next=NULL;
        Q[key]->next=q;
    }
}

void crateH(int p){
    int i,j,num,h[MAX];
    printf("请输入哈希表的关键字个数：");
    scanf("%d",&num);
    printf("请输入哈希表中的关键字:\n");
    for ( i = 0; i < num; i++)
        scanf("%d",&h[i]);
        for ( i = 0; i <num ; i++) {
            j= SearchHash(HA,h[i],p);
            if(j==1)
                printf("哈希表中已存在该关键字");
            else
                InsertHash(HA,h[i],p);
        }
}

void MenuList()
{   printf("\n\n\n****************************************************\n");
    printf("****************       查找   ************\n");
    printf("**** 1  ------ 顺序查找                   ****\n");
    printf("**** 2  ------折半查找               ****\n");
    printf("**** 3  ------生成二叉排序树       ****\n");
    printf("**** 4  ------查找值为X的元素，不存在则插入     ****\n");
    printf("**** 5  ------生成哈希表(开放地址法)     ****\n");
    printf("**** 6  ------生成哈希表(链地址法)     ****\n");
    printf("**** 7  ------哈希查找     ****\n");
    printf("**** 8  ------判断二叉排序树     ****\n");
    printf("**** 9  ------查找最大值最小值     ****\n");
    printf("****************************************************\n");
}

void main ()
{
    RecType R[11];
    KeyType k;
    hstable  La;
    BiTree T;
    int i,j,p;
    int n = 10 ,s=100;
    int a[11];
    printf("输入10个元素构造顺序查找表:\n");
    for (i = 1;i<=n;i++){
        scanf("%d",&a[i]);
        R[i].key = a[i];
       // fflush(stdin);
    }
    printf("\n");
    while(s!=0)
    {   MenuList();
        printf("选择查找方法 :");
        scanf("%d",&s);
        if (s==1)
        {
            printf("输入待查找关键字 :");
            scanf("%d",&k);
            if ((i=seqsearch(R,n,k))!=0)
                printf("查找成功，元素：  %2d 　位置是： %2d\n",k,i);
            else
                printf("查找失败\n ");
        }
        if (s==2)
        {
            printf("输入待查找关键字 :");
            scanf("%d",&k);
            if ((i=BinSearch(R,n,k))!=0)
                printf("查找成功，元素：  %2d 　位置是： %2d\n",k,i);
            else
                printf("查找失败\n ");
        }
        if(s==3){
            printf("生成二叉排序树\n");
            createtree();
            printf("生成成功");
        }
         if(s==4)  {
             printf("输入待查找关键字 :");
             scanf("%d",&k);
             find_tree(k);
         }
         if(s==5){
             j= initHash(&La);
             if(j==1){
                 printf("哈希函数为hash(key)=key mod p,请输入p的值:");
                 scanf("%d",&p);
                 creatHashTable(&La,p);
                 printf("哈希表生成成功！\n");
                 printf("生成的哈希表为:\n");
                 for ( i = 0; i < La.Length; i++) {
                     printf("%d ",La.data[i]);
                 }
             }}
         if(s==6){
             printf("哈希函数为hash(key)=key mod p,请输入p的值:");
             scanf("%d",&p);
             HA=(HNode **) malloc(sizeof(HNode*)*p);
             InitHash(p);
             crateH(p);
             prtLH(HA,p);
         }

         if(s==7){
             printf("请输入要查找的关键字的值:");
             scanf("%d",&k);
             j= HashSearch(&La,k,p);
             if(j==1)
                 printf("查找成功\n");
             else
                 printf("查找失败");
         }
         if(s==8){
             printf("判断二叉排序数");
             printf("请输入二叉树的先序遍历序列，0代表空树:");
             T=CreateBiTree(NULL);
             i=Is_BSTree(T);
             if(i==1)
                 printf("是二叉排序树");
             else
                 printf("不是二叉排序树");
         }
         if(s==9){
             printf("找到最大最小值\n");
             printf("请输入要查找的元素: \n");
             scanf("%d", &k);
             findMaxMin(k, root);
             printf("\n");
         }

    }

}