实验五 查找综合

1. 采用二分查找的方法实现查找
   （1）定义顺序表的存储结构；
   （2）实现顺序表上二分查找；
2. 采用二叉排序树实现查找
   （1）定义二叉链表的存储结构；
   （2）实现二叉排序树的建立、查找、插入和删除结点操作；
   第一题

#include<iostream>
#include<stdio.h>
#include<cstdio>
#include<string.h>
#include<cstring>
#include<string>
#include<queue>
#include<malloc.h>//头文件包含malloc函数，用来申请内存空间 
#include<algorithm>
#include<math.h>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define INFEASIBLE -1
#define N 10 // 数据元素个数
typedef int Status;//Status是函数的类型，其值是函数结果状态代码
typedef int KeyType; // 设关键字域为整型

//数据元素的类型  
struct ElemType
{
    int key;
};

//静态查找表的顺序存储结构  
struct SSTable
{
    ElemType *elem;//数据元素的存储空间的基地址，（0号单元不用)  
    int length;//表的长度  
};

//对于两个数值型变量的比较约定为如下的宏定义  
#define EQ(a,b) ((a) == (b))  
#define LT(a,b) ((a) < (b))  
#define LQ(a,b) ((a) <= (b))  

//由n个数据元素的数组r，构造静态查找表ST  
void Create_Seq(SSTable &ST, ElemType r[], int n)
{
    int i;
    //ST.elem=(ElemType*)calloc(n+1,sizeof(ElemType));//动态生成n+1个数据元素空间，0号单元不用  
    ST.elem = (ElemType*)malloc((n + 1)*sizeof(ElemType));
    if (!ST.elem)
        exit(ERROR);
    for (i = 1; i <= n; i++)
        ST.elem[i] = r[i - 1];//将数组的元素依次赋值给ST  
    ST.length = n;
}

void Ascend(SSTable &ST)//重建静态查找表为按照关键字为非降序排列  
{
    int i, j, k;
    for (i = 1; i < ST.length; i++)
    {
        k = i;
        ST.elem[0] = ST.elem[i];//待比较的元素存入0号单元  
        for (j = i + 1; j <= ST.length; j++)
        {
            if (LT(ST.elem[j].key, ST.elem[0].key))
            {
                k = j;
                ST.elem[0] = ST.elem[j];
            }
        }
        if (k != i)//有更小的值则交换  
        {
            ST.elem[k] = ST.elem[i];
            ST.elem[i] = ST.elem[0];
        }
    }
}

//在有序表ST中，折半查找关键字等于key的数据元素,返回在表中的位置（查找有序的顺序表）  
int Search_Bin(SSTable &ST, long key)
{
    int low, mid, high;
    low = 1;
    high = ST.length;//置区间初值  
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (EQ(ST.elem[mid].key, key))
            return mid;
        else if (LT(key, ST.elem[mid].key))
            high = mid - 1;//继续在前半个区间查找  
        else
            low = mid + 1;//继续在后半个区间查找  
    }
    return 0;//没有查找到  
}

//顺序表的有序查找  
int main()
{
    SSTable st;
    int i,n;
    int s;
    ElemType r[50];
    printf("请输入您所要查找的序列的元素个数：");
    scanf("%d", &n);
    printf("请按照从小到大的顺序输入各元素的值：");
    for (int i = 0; i < n; i++) {
        scanf("%d", &r[i]);
    }
    Create_Seq(st, r, n);//建立无序的顺序查找表  
    Ascend(st);//将无序的查找表重建为按照关键字非降序排列的查找表  
    printf("请输入你要查找值得关键字：");
    scanf("%d", &s);
    i = Search_Bin(st, s);
    if (i)
        printf("存在您要找的关键字%d，且是第%d个关键字\n", st.elem[i].key, i);
    else
        printf("不存在您要找的关键字！");


    return 0;
}

第二题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
int data;
int height;
Node *rchild,*lchild,*parent;
}BSTNode,*BSTree;
BSTNode *T;
void insertBST(int k)
{
BSTNode *y=NULL;
BSTNode *x=T;
BSTNode *z;
z=(BSTNode *)malloc(sizeof(Node));
z->data=k;
z->height=1;
z->lchild=NULL;
z->rchild=NULL;
while(x!=NULL)
{
y=x;
if(z->data<x->data)
{
x=x->lchild;
z->height++;
}
else
{
x=x->rchild;
z->height++;
}
}
z->parent=y;
if(y==NULL)	T=z;
else
{
if(z->data<y->data)	y->lchild=z;
else y->rchild=z;
}
}
void Inorder(BSTNode *u)
{
if(u==NULL) return;
Inorder(u->lchild);
printf("%d ",u->data);
Inorder(u->rchild);
}
double CalLength(BSTree *T)
{
static double length=0;
static int n=0;
if(*T)
{
length+=(*T)->height;
CalLength(&(*T)->lchild);
n++;
CalLength(&(*T)->rchild);
}
return length/n;
}
BSTree SearchDeleteBST(int  key)  //删除函数
{
BSTree p=T,q=NULL,s,f;
   while(p!=NULL)   //查找要删除的点
    {
        if(p->data==key)
break;
        q=p;	//q指向要删结点的父母
        if(p->data>key)   p=p->lchild;
        else p=p->rchild;
    }
    if(p==NULL)
return  T;    //查找失败
    if(p->lchild==NULL)     //p指向当前要删除的结点
    {
        if(q==NULL)   T=p->rchild;  
        else if(q->lchild==p)    q->lchild=p->rchild;  //p为q的左孩子
        else q->rchild=p->rchild;	//p为q的右孩子
        free(p);
    }
else
{           //p的左孩子不为空
        f=p;
        s=p->lchild;
        while(s->rchild)   //左拐后向右走到底
        {
            f=s;
            s=s->rchild;
        }
        if(f==p)    f->lchild=s->lchild;  //重接f的左子树
        else    f->rchild=s->lchild;   //重接f的右子树
        p->data=s->data;
        free (s);
    }
    return  T;
}
int searchBST(BSTree T,int key,BSTree f,BSTree *p) //查找函数
{
    if(!T)
{
*p=f;
return 0;
}         //查找不成功
else if(key==T->data)    
{
*p=T;
return 1;
} /*查找成功*/
else if(key<T->data)   searchBST(T->lchild,key,T,p);   //在左子树中继续查找
else  searchBST(T->rchild,key,T,p); //在右子树中继续查找
}
int main()
{
    int num;
    char ch;
    BSTree p=NULL;
printf("输入一串数，每个数以空格分开:");
    do
{
        scanf("%d",&num);
        insertBST(num);
        scanf("%c",&ch);
        if(ch=='\n') break;
    }while(ch!='\n');
    printf("中序遍历输出结果为:\n");
    Inorder(T); 
    printf("\n");
    printf("平均查找长度为：%3.1f",CalLength(&T));
    printf("\n");
    printf("输入查找元素并删除该结点:");
    scanf("%d",&num); 
    if(searchBST(T,num,NULL,&p))
    {
        T=SearchDeleteBST(num);
        printf("\n删除成功!中序遍历输出：\n");
        Inorder(T);
    }
    else
        printf("无%d",num);
    return 0;
}