数据结构实验报告（五）

实验报告五 查找的相关操作

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define INFINITY INT_MAX
#define MAXSIZE 20

using namespace std;
//1.折半查找
typedef int KeyType;
typedef struct
{
    KeyType key;
    char data1;
}ElemType;
typedef struct
{
    ElemType data[MAXSIZE];
    int length;

}SeqList;

void createSeqList(SeqList &l)
{
    cout<<"请输入关键字个数"<<endl;
    cin>>l.length;
    cout<<"请顺序输入一组有序的数据及其关键字（key,data1）"<<endl;
    for (int i=1;i<=l.length;i++)
    {
        scanf("%d%c",&l.data[i].key,&l.data[i].data1);
    }
}

int Search_Bin(SeqList &l,KeyType key)
{
   int low=1,high=l.length;
   int mid;
   while (low<=high)
   {
       mid=(low+high)/2;
       if (key == l.data[mid].key)
        return mid;
       else if (key < l.data[mid].key )
        high=mid-1;
       else
        low=mid+1;
   }
   return 0;
}
//2.二叉排序树
typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *left,*right;
}BiTNode,*BiTree;

// 查找二叉排序树
int SearchBST(BiTree t,KeyType key,BiTree f,BiTree &p)
{
    if (!t) {p=f;return 0;}
    else if (key==t->data.key){p=t;return 1;}
    else if (key <t->data.key)
        return SearchBST(t->left,key,t,p);
    else return SearchBST(t->right,key,t,p);
}
// 插入一个数据到二叉排序树
int InsertBST(BiTree &t,ElemType e)
{
    BiTree p,s;
    if (!SearchBST(t,e.key,NULL,p))
    {
        s=(BiTree)malloc(sizeof(BiTNode));
        s->data.key=e.key;
        s->data.data1=e.data1;
        s->left=s->right=NULL;
        if (!p)
            t=s;
        else if (e.key < p->data.key )
            p->left=s;
        else
            p->right=s;
        return 1;
    }
    else
        return 0;
}
// 循环插入一组数据，建立二叉排序树
void InsertBST_for()
{
    void InOrderTraverse(BiTree &t);
    void DeleteBST(BiTree &t,KeyType key);
    BiTree t;
    t=NULL;
    ElemType e;
    int n;
    cout<<"请输入您要输入的数据个数"<<endl;
    cin>>n;
    cout<<"请依次输入您要插入的数据及其关键字（key,data1）"<<endl;
    for (int i=0;i<n;i++)
    {
      cin>>e.key>>e.data1;
      InsertBST(t,e);
    }
     cout<<"中序遍历输出的结果为："<<endl;
     InOrderTraverse(t);
     cout<<"请输入您要删除的某一元素的关键字"<<endl;
     KeyType key;
     cin>>key;
     DeleteBST(t,key);
     cout<<"删除指定元素后的中序遍历结果为："<<endl;
     InOrderTraverse(t);




}
// 中序遍历二叉排序树
void InOrderTraverse(BiTree &t)
{
    if (t)
    {
        InOrderTraverse(t->left);
        cout<<t->data.key<<" ";
        InOrderTraverse(t->right);
    }
}
// 二叉排序树删除:删除某一指定结点
int Delete(BiTree &p)
{
    BiTree q,s;
    if (!p->right)
    {
        q=p;
        p=p->left;
        free(q);
    }
    else if (!p->right)
    {
        q=p;
        p=p->right;
        free(q);
    }
    else
    {
        q=p;
        s=p->left;
        while (s->right)
        {
            q=s;
            s=s->right;
        }
        p->data.key=s->data.key;
        p->data.data1=s->data.data1;

        if (q!=p)
            q->right=s->left;
        else
            q->left=s->left;
        delete(s);

    }
    return 1;
}
// 删除某关键字
int DeleteBST(BiTree &t,KeyType key)
{
    if (!t)
        return 0;
    else
    {
        if (key == t->data.key )
            return Delete(t);
        else if (key < t->data.key)
        return DeleteBST(t->left,key);
        else
            return DeleteBST(t->right,key);
    }
    return 1;
}
// AVL
typedef struct BSTNode
{
    ElemType data;
    int bf;
    struct BSTNode *left,*right;
}BSTNode,*BSTree;

// 右旋
void R_Rotate(BSTree &p)
{
    BSTree lc;
    lc=p->left;
    p->left=lc->right;
    lc->right=p;
    p=lc;

}
//左旋
void L_Rotate(BSTree &p)
{
    BSTree lc;
    lc=p->right;
    p->right=lc->left;
    lc->left=p;
    p=lc;
}
//左平衡
void LeftBalance(BSTree &t)
{
    BSTree lc,rd;
    lc=t->left;
    switch(lc->bf)
    {
    case 1:
        t->bf=lc->bf=0;
        R_Rotate(t);
        break;
    case -1:
        rd=lc->right;
        switch(rd->bf)
        {
        case 1:
            t->bf=-1;
            lc->bf=0;
            break;
        case 0:
            t->bf=lc->bf=0;
            break;
        case -1:
            t->bf=0;
            lc->bf=1;
            break;
        }
        rd->bf=0;
        L_Rotate(t->left);
        R_Rotate(t);
    }

}
//右平衡
void RightBalance(BSTree &t)
{
    BSTree lc,rd;
    lc=t->right;
    switch(lc->bf)
    {
    case 1:
        rd=lc->left;
        switch(rd->bf)
        {
        case 1:
            t->bf=0;
            lc->bf=-1;
            break;
        case 0:
            t->bf=lc->bf=0;
            break;
        case -1:
            t->bf=1;
            lc->bf=0;
            break;
        }
        rd->bf=0;
        R_Rotate(t->right);
        L_Rotate(t);
        break;
    case -1:
        t->bf=lc->bf=0;
        L_Rotate(t);
    }

}
//插入建立平衡二叉排序树
int InsertAVL(BSTree &t,ElemType e,bool taller)
{
    if (!t)
    {
        t=(BSTree )malloc(sizeof(BSTNode));
        t->bf=0;
        t->left=t->right=NULL;
        t->data.data1=e.data1;
        t->data.key=e.key;
        taller=true;//树长高则为正
    }
    else
    {
        if (e.key==t->data.key)
        {
            taller=false;
            return 0;
        }
        if (e.key < t->data.key)
        {
            if (!InsertAVL(t->left,e,taller))
                return 0;
                if (taller)
                {
                    switch(t->bf)
                    {
                        case 1:
                            LeftBalance(t);
                            taller=false;
                            break;
                        case 0:
                            t->bf=1;
                            taller=true;
                            break;
                        case -1:
                            t->bf=0;
                            taller=false;
                            break;
                    }
                }
        }
        else
        {
            if (!InsertAVL(t->right,e,taller))
                return 0;
                if (taller)
                {
                    switch(t->bf)
                    {
                        case 1:
                            t->bf=0;
                            taller=false;
                            break;
                        case 0:
                            t->bf=-1;
                            taller=true;
                            break;
                        case -1:
                            RightBalance(t);
                            taller=false;
                            break;
                    }
                }
        }
    }
    return 1;
}
// 中序遍历平衡二叉排序树
void InOrderTraverse_BST(BSTree &t)
{
    if (t)
    {
        InOrderTraverse_BST(t->left);
        cout<<t->data.key<<" ";
        InOrderTraverse_BST(t->right);
    }
}
// 线性探测法建立散列表
typedef struct
{
    ElemType data[MAXSIZE];
    int count;
}HashTable;
// 哈希函数
int Hash(KeyType k)
{
    int p=13;
    return k%13;
}
//发生冲突之后求出下一探查地址
void collision(HashTable h,int &p)
{
    p=(p+1+MAXSIZE)%MAXSIZE;
}
// 在哈希表中查找某关键字
int SearchHash(HashTable h,KeyType key,int &p)
{
    p=Hash(key);// 哈西地址
    while (h.data[p].key!=NULL && key!=h.data[p].key )
    collision(h,p);

    if (key==h.data[p].key)
        return 1;
    else
        return 0;

}
// 插入机建立线性探测哈希表
int InsertHash(HashTable &h,ElemType e)
{
    int p;
    h.count=0;
    if (SearchHash(h,e.key,p))
        return 0;
    else
        h.data[p].key=e.key;
        h.data[p].data1=e.data1;
        h.count++;
        return 1;
}
// 遍历输出线线性探测哈希表
void TraverseHash(HashTable h)
{
    int i;
    for (i=0;i<MAXSIZE;i++)
        cout<<"("<<h.data[i].key<<","<<h.data[i].data1<<")";
    cout<<endl;
}

// 外拉链法建立哈希表
typedef struct Node
{
    ElemType e;
    struct Node *next;
}Node,HashTable2[MAXSIZE];
// 查找外拉链表
int searchHash2(HashTable2 h,ElemType e,int &p)
{
    p=Hash(e.key);// 哈西地址
    Node *q;
    q=h[p].next;
    while (q)
    {
       if (q->e.key==e.key)
            return 1;
        q=q->next;
    }
    return 0;
}
// 插入建立外拉链表
int InsertHash2(HashTable2 h,ElemType e)
{
    int p;
    Node *q;
    if (searchHash2(h,e,p))
        return 0;
    else
    {
       q=(Node*)malloc(sizeof(Node));
       q->e.key=e.key;
       q->e.data1=e.data1;
       q->next=h[p].next;//头插法插入元素
       h[p].next=q;
    }
    return 1;
}
// 遍历外拉链表
void TraverseHash2(HashTable2 h)
{
    int i;
    Node *p;
    for (i=0;i<MAXSIZE;i++)
    {
       p=h[i].next;
       while (p)
       {
           cout<<"("<<p->e.key<<","<<p->e.data1<<")";
           p=p->next;
       }
    }
}


int main()
{   cout<<"--------------------------------------------------------"<<endl;
    cout<<"1.Search_Bin():采用折半查找实现某一已知的关键字的查找"<<endl;
    cout<<"2.InsertBST()&&DeleteBST():插入算法建立二叉排序树并删除某指定元素"<<endl;
    cout<<"3.InsertAVL():建立AVL树并实现删除某一指定关键字元素"<<endl;
    cout<<"4.InsertHash():线性探测法建立哈希表"<<endl;
    cout<<"5.InsertHash2():外拉链法建立哈希表"<<endl;
    cout<<"--------------------------------------------------------"<<endl;
ll1:cout<<"请输入您选择的函数序号"<<endl;
    int x;cin>>x;
    ElemType e;int n;
    switch(x)
    {
    case 1:
    {
    SeqList l;
    createSeqList(l);
    cout<<"请输入任一关键字"<<endl;
    KeyType key;
    cin>>key;
    int location=Search_Bin(l,key);
    printf("查找位置为：%d
",location);
    break;
    }

    case 2:
    {
       InsertBST_for();
       break;
    }

    case 3:
        {
            BSTree t1;
            t1=NULL;
            cout<<"请输入数据个数"<<endl;
            cin>>n;
            cout<<"请输入一组数据（key,data1）以建立平衡二叉树"<<endl;
            for (int i=0;i<n;i++)
            {
                cin>>e.key>>e.data1;
                InsertAVL(t1,e,false);
            }
            cout<<"建立结束，现在中序遍历"<<endl;
            InOrderTraverse_BST(t1);
            break;
        }
    case 4:
        HashTable h;
        for (int i=0;i<MAXSIZE;i++)
    {
      h.data[i].key=0;
      h.data[i].data1='z';
    }
        cout<<"请输入元素个数"<<endl;
        cin>>n;
        cout<<"请输入一组关键字（key,data1）"<<endl;
        for (int i=0;i<n;i++)
        {
            cin>>e.key>>e.data1;
            InsertHash(h,e);
        }
        cout<<"建立结束，遍历哈希表,(0,z)表示NULL"<<endl;
        TraverseHash(h);

        break;

    case 5:
        HashTable2 h1;
        for (int i=0;i<MAXSIZE;i++)
    {
     h1[i].next=NULL;
    }
        cout<<"请输入元素个数"<<endl;
        cin>>n;
        cout<<"请输入一组关键字（key,data1）"<<endl;
        for (int i=0;i<n;i++)
        {
            cin>>e.key>>e.data1;
            InsertHash2(h1,e);
        }
        cout<<"建立结束，遍历哈希表"<<endl;
        TraverseHash2(h1);
        break;
    }
    cout<<"您是否还要继续测试其他函数？y/n"<<endl;
    fflush(stdin);
    char z;
    cin>>z;
    if (z=='y')
        goto ll1;
    else
    return 0;
}