下载文档原格式
实验B06: 静态表的查找操作实验一、实验名称和性质二、实验目的1．掌握顺序查找操作的算法实现。
2．掌握二分查找操作的算法实现及实现该查找的前提。
3．掌握索引查找操作的算法实现。
三、实验内容1．建立顺序查找表，并在此查找表上实现顺序查找操作（验证性内容）。
2．建立有序顺序查找表，并在此查找表上实现二分查找操作（验证性内容）。
3．建立索引查找表，并在此查找表上实现索引查找操作（设计性内容）。
四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号以及模块：Windows环境下的TurboC2.0以上或VC++五、知识准备前期要求掌握查找的含义和顺序查找、二分查找及索引查找操作的方法。
六、验证性实验1．实验要求编程实现如下功能：（1）根据输入的查找表的表长n和n个关键字值，建立顺序查找表，并在此查找表中用顺序查找方法查找给定关键值的记录，最后输出查找结果。
（2）根据输入的查找表的表长n和n个按升排列的关键字值，建立有序顺序查找表，并在此查找表中用二分查找方法查找给定关键值的记录，最后输出查找结果。
（3）主程序中要求设计一个菜单，允许用户通过菜单来多次选择执行哪一种查找操作。
2. 实验相关原理：查找表分别静态查找表和动态查找表两种，其中只能做引用操作的查找表称为静态查找表。
静态查找表采用顺序存储结构的数据描述为：#define MAXSIZE 100 /*顺序查找表的最大长度*/typedef int keytype;typedef struct{keytype key;}redtype;typedef struct{redtype elem[MAXSIZE];int length;}Sstable;【核心算法提示】查找操作是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。
若查找表中存在这样一个记录，则称“查找成功”。
查找结果给出整个记录的信息，或指示该记录在查找表中的位置；若在查找表中不存在这样的记录，则称“查找不成功”。
实验六-静态表的查找实验目的：掌握静态表的两种查找方法（顺序查找、折半查找）的算法思想及查找效率实验内容：1.如果可以编写程序，在顺序表中实现两种方法的查找。
建议编写一个程序，在程序中需要包含顺序表的创建、顺序查找、折半查找、显示这四个子函数。
（可以考虑增加一个排序的函数）程序要考虑到查找存在的元素和不存在的元素，返回查找结果为元素是否查找到的信息，元素存在的位置和比较的次数。
可以在第一个程序（顺序表的基本操作）基础上进行修改，添加两个子函数即可。
2.如果不能编写程序，在作业本上对给出的序列用两种方法详细描述查找过程。
要求：（1）顺序查找：描述查找的过程，并写出最终的比较次数。
（2）折半查找：先将查找表中的元素排序，对排序后的查找表进行折半查找，能描述出每一次区间的变化，并记录比较的次数。
序列：（1）静态查找表（2,31,7,68,97,12,36,14）分别查找key=68,key=60（2）静态查找表（49,73,56,53,20,51,39,11）分别查找Key=11,key=80#include <stdio.h> //C语言头文件#define maxsize 100 //宏定义变量typedef int ELemType; //int换名为ESTemTypetypedef struct{ELemType elem[maxsize];int Length;int Listsize;}SSTable;SSTable ST; //定义顺序表STSSTable CreatSSTable(SSTable ST,int n){//创建顺序表的函数int i;ST.Length=0; //顺序表ST的长度初始化为0ST.Listsize=maxsize; //顺序表的最大容量初始化为100printf("请输入顺序表的%d个数:\n",n);for (i=1;i<=n;i++) //循环给顺序表数据域赋值{scanf("%d",&ST.elem[i]);ST.Length++;//顺序表ST的长度加一}printf("\n");return(ST);}SSTable Search_Seq(SSTable ST,int n){//顺序查找int i;ST.elem[0]=n;for(i=ST.Length;ST.elem[i]!=n;i--);if(i==0)printf("查找不成功!\n");elseprintf("元素在第%d位\n查找成功!\n",i);return ST;}SSTable Binary_Search(SSTable ST,int n){int mid,flag=0,low=1,high=ST.Length;while(low<=high){mid=(low+high)/2;if(n<ST.elem[mid])high=mid-1;elseif(n>ST.elem[mid])low=mid+1;else{flag=mid;printf("查找元素在第%d位\n",flag);break;}}return ST;}void display(SSTable ST){//输出显示函数int i;printf("线性表为：\n");for (i=1;i<=ST.Length;i++)//循环输出列表中的数据printf("%d ",ST.elem[i]);printf("\n");}void main( ){int n,f=1;int i,d;int no;/*cSTrscr();*/while(f){ printf("请输入菜单项0或1、2、3、4来选择操作:\n0退出\n1顺序表创建\n2顺序查找\n3折半查找\n");scanf("%d",&no);switch(no){case 1: printf("请输入要创建的顺序表的长度n:\n");scanf("%d",&n);printf("\n");ST=CreatSSTable(ST,n);display(ST);break;case 2: printf("请输入要查找的元素:\n");scanf("%d",&i);ST=Search_Seq(ST,i);display(ST);break;case 3: printf("请输入要查找的元素:");scanf("%d",&d);printf("\n");ST=Binary_Search(ST,d);display(ST);break;case 0: break;}printf("想继续菜单操作吗?\nno.1:continue\nno.0:exit\n");scanf("%d",&f);}}。
湖南科技学院综合性实验指导书实验名称：静态、动态查找表及其应用编号：实验5实验项目性质：综合性所涉及课程：数据结构计划学时：4一、实验目的1. 理解各种排序、查找方法的特点，并能加以灵活应用；2. 掌握常用排序、查找算法的编程实现；3. 熟练掌握C++的输入输出编程。
二、实验内容用C++编程解决以下问题：已知某商场有十万件商品，每件商品的价格保存在文件“data.txt”中，价格相同的为同一种商品。
某人手头有5万块，元旦快到了，准备到商场给女友买两件礼物，钱要花光，两件礼物不能相同，请问他有多少种选择？三、实验（设计）仪器设备和材料清单PC、CodeBlocks10.5四、实验要求要求自行确定数据结构，选用合适的排序、查找算法解决问题。
五、实验步骤及结果测试①问题分析；②数据结构及算法设计；③算法实现及测试；④算法分析、完成实验报告。
六、考核形式实验报告（50%）+程序（50%）七、实验报告要求要求有问题分析、解决思路、算法代码、运行（或测试）结果、算法分析等内容。
八、实验指导1. 快速排序算法void QuickSort(ElemType R[],int left, int right){int i=left, j=right;ElemType temp=R[i];while (i<j){while((R[j]>temp)&&(j>i))j=j-1;if (j>i){R[i]=R[j];i=i+1;}while((R[i]<=temp)&&(j>i))i=i+1;if (i<j){R[j]=R[i];j=j-1;}}//一次划分得到基准值的正确位置R[i]=temp;if(left<i-1)quicksort(R,left,i-1); //递归调用左子区间if(i+1<right)quicksort(R,i+1,right); //递归调用右子区间}2. 二分查找算法int Search_Bin(SSTable ST,KeyType key){// 在有序表ST中折半查找其关键字等于key的数据元素。
数据结构实验报告-静态查找表中的查找第一篇：数据结构实验报告-静态查找表中的查找数据结构实验实验一静态查找表中的查找一、实验目的：1、理解静态查找表的概念2、掌握顺序查找和折半查找算法及其实现方法3、理解顺序查找和折半查找的特点，学会分析算法的性能二、实验内容：1、按关键字从小到大顺序输入一组记录构造查找表，并且输出该查找表；2、给定一个关键字值，对所构造的查找表分别进行顺序查找和折半查找，输出查找的结果以及查找过程中“比较”操作的执行次数。
三、实验要求：1、查找表的长度、查找表中的记录和待查找的关键字值要从终端输入；2、具体的输入和输出格式不限；3、算法要具有较好的健壮性，对错误操作要做适当处理；4、输出信息中要标明所采用的查找方法类型。
实验二基于二叉排序树的查找一、实验目的：1、理解动态查找表和二叉排序树的概念2、掌握二叉排序树的构造算法及其实现方法3、掌握二叉排序树的查找算法及其实现方法二、实验内容：1、输入一组记录构造一颗二叉排序树，并且输出这棵二叉排序树的中序序列；2、给定一个关键字值，对所构造的二叉排序树进行查找，并输出查找的结果。
三、实验要求：1、二叉排序树中的记录和待查找的关键字值要从终端输入；2、输入的记录格式为(整数，序号)，例如(3, 2)表示关键字值为3，输入序号为2的记录；3、算法要具有较好的健壮性，对错误操作要做适当处理。
四、程序实现：(1)实现顺序查找表和折半查找表：#include #define MAX_LENGTH 100 typedef struct {int key[MAX_LENGTH];int length;}stable;int seqserch(stable ST,int key,int &count){int i;for(i=ST.length;i>0;i--){count++;if(ST.key[i]==key)return i;}return 0;}int binserch(stable ST,int key,int &count){int low=1,high=ST.length,mid;while(low<=high){count++;mid=(low+high)/2;if(ST.key[mid]==key)return mid;else if(keyhigh=mid-1;elselow=mid+1;}return 0;}main(){stable ST1;inta,b,k,x,count1=0,count2=0,temp=0;ST1.length=0;printf(“请按从小到大的顺序输入查找表数据：(-1代表结束！)n”);for(a=0;a{s canf(“%d”,&temp);if(temp!=-1){ST1.key[a]=temp;ST1.length++;}elsebreak;}printf(“输入数据为：n”);for(b=0;b{printf(“%d ”,ST1.key[b]);}printf(“n请输入要查找的数据：”);scanf(“%d”,&k);a=seqserch(ST1,k,count1)+1;printf(“n顺序查找：该数据的位置在第：%d个n”,a);printf(“查找次数为：%dnn”,count1-1);a=binserch(ST1,k,count2)+1;printf(“折半查找：该数据的位置在第：%d个n”,a);printf(“查找次数为：%dn”,count2-1);}（2）二叉排序树的查找：#include #includetypedef struct node {int data;int key;struct node *left,*right;}bitnode,*bittree;void serchbst(bittree T,bittree *F,bittree *C,int data){while(T!=NULL){if(T->data==data){*C=T;break;}else if(datadata){*F=T;T=T->left;}else{*F=T;T=T->right;}}return 0;}int insertbst(bittree *T,int key,int data){bittree F=NULL,C=NULL,s;serchbst(*T,&F,&C,data);if(C!=NULL)return 0;s=(bittree)malloc(sizeof(bitnode));s->data=data;s->key=key;s->left=s->right=NULL;if(F==NULL)*T=s;else if(datadata)F->left=s;elseF->right=s;return 1;}void creatbst(bittree *T){int key,data;*T=NULL;printf(“请输入数据以构造二叉排序树：(数据格式为:m n(-1000,-1000)代表结束)n”);scanf(“%d%d”,&key,&data);while(key!=-1000 || data!=-1000){insertbst(T,key,data);scanf(“%d%d”,&key,&data);} }void midTraverse(bittree T){if(T!=NULL){midTraverse(T->left);printf(“(%d,%d)”,T->key,T->data);midTraverse(T->right);} }main(){bittreeT=NULL,C=NULL,F=NULL;int key,data,temp;creatbst(&T);printf(“此二叉树的中序序列为：”);midTraverse(T);printf(“n请输入要查找的关键字：”);scanf(“%d”,&data);serchbst(T,&F,&C,data);printf(“此关键字的数据为：%dn”,C->key);}五、实现结果：(1)顺序查找和折半查找：(2)二叉树排序树查找：六、实验之心得体会：（1）在这次实验中，我基本上掌握了顺序查找、折半查找和二叉排序树查找的基本思想和实现方法，让我体会到了写程序时，不仅要考虑是否能够调试出结果，还要考虑程序实现的效率，这是一个编程人员必须要具备的一项总要的素质。
实验B06: 静态表的查找操作实验一、实验名称和性质二、实验目的1．掌握顺序查找操作的算法实现。
2．掌握二分查找操作的算法实现及实现该查找的前提。
3．掌握索引查找操作的算法实现。
三、实验内容1．建立顺序查找表，并在此查找表上实现顺序查找操作（验证性内容）。
2．建立有序顺序查找表，并在此查找表上实现二分查找操作（验证性内容）。
3．建立索引查找表，并在此查找表上实现索引查找操作（设计性内容）。
四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号以及模块：Windows环境下的TurboC2.0以上或VC++五、知识准备前期要求掌握查找的含义和顺序查找、二分查找及索引查找操作的方法。
六、验证性实验1．实验要求编程实现如下功能：（1）根据输入的查找表的表长n和n个关键字值，建立顺序查找表，并在此查找表中用顺序查找方法查找给定关键值的记录，最后输出查找结果。
（2）根据输入的查找表的表长n和n个按升排列的关键字值，建立有序顺序查找表，并在此查找表中用二分查找方法查找给定关键值的记录，最后输出查找结果。
（3）主程序中要求设计一个菜单，允许用户通过菜单来多次选择执行哪一种查找操作。
2. 实验相关原理：查找表分别静态查找表和动态查找表两种，其中只能做引用操作的查找表称为静态查找表。
静态查找表采用顺序存储结构的数据描述为：#define MAXSIZE 100 /*顺序查找表的最大长度*/typedef int keytype;typedef struct{keytype key;}redtype;typedef struct{redtype elem[MAXSIZE];int length;}Sstable;【核心算法提示】查找操作是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。
若查找表中存在这样一个记录，则称“查找成功”。
查找结果给出整个记录的信息，或指示该记录在查找表中的位置；若在查找表中不存在这样的记录，则称“查找不成功”。
数据结构——第五章查找：01静态查找表和动态查找表1.查找表可分为两类：（1）静态查找表：仅做查询和检索操作的查找表。
（2）动态查找表：在查询之后，还需要将查询结果为不在查找表中的数据元素插⼊到查找表中；或者，从查找表中删除其查询结果为在查找表中的数据元素。
2.查找的⽅法取决于查找表的结构：由于查找表中的数据元素之间不存在明显的组织规律，因此不便于查找。
为了提⾼查找效率，需要在查找表中的元素之间⼈为地附加某种确定的关系，⽤另外⼀种结构来表⽰查找表。
3.顺序查找表：以顺序表或线性链表表⽰静态查找表，假设数组0号单元留空。
算法如下：int location(SqList L, ElemType &elem){ i = 1; p = L.elem; while (i <= L.length && *(p++)!= e) { i++; } if (i <= L.length) { return i; } else { return 0; }}此算法每次循环都要判断数组下标是否越界，改进⽅法：加⼊哨兵，将⽬标值赋给数组下标为0的元素，并从后向前查找。
改进后算法如下：int Search_Seq(SSTable ST, KeyType kval) //在顺序表ST中顺序查找其关键字等于key的数据元素。
若找到，则函数值为该元素在表中的位置，否则为0。
{ ST.elem[0].key = kval; //设置哨兵 for (i = ST.length; ST.elem[i].key != kval; i--) //从后往前找，找不到则返回0 { } return 0;}4.顺序表查找的平均查找长度为：(n+1)/2。
5.上述顺序查找表的查找算法简单，但平均查找长度较⼤，不适⽤于表长较⼤的查找表。
若以有序表表⽰静态查找表，则查找过程可以基于折半进⾏。
算法如下：int Search_Bin(SSTable ST, KeyType kval){ low = 1; high = ST.length; //置区间初值 while (low <= high) { mid = (low + high) / 2; if (kval == ST.elem[mid].key) { return mid; //找到待查元素 } else if (kval < ST.elem[mid].key) { high = mid - 1; //继续在前半区间查找 } else { low = mid + 1; //继续在后半区间查找 } } return 0; //顺序表中不存在待查元素} //表长为n的折半查找的判定树的深度和含有n个结点的完全⼆叉树的深度相同6.⼏种查找表的时间复杂度：（1）从查找性能看，最好情况能达到O(logn)，此时要求表有序；（2）从插⼊和删除性能看，最好情况能达到O(1)，此时要求存储结构是链表。
数据结构实验报告题目：静态查找表的实现成绩____________________2014年6月10号静态查找表抽象数据类型的实现一、设计任务、要求及所用的软件环境或工具：1.设计任务及要求：用C语言实现静态查找表的抽象数据类型2.软件环境：win73.开发工具：C-Free二、抽象数据类型的实现1. 题目采用顺序存储和链式存储为存储结构，实现抽象数据类型StaticSearchTable。
ADT StaticSearchTable{数据对象D：D是具有相同特性的数据元素的集合。
各个数据元素含有类型相同的关键字，可唯一标识元素的关键字。
数据关系R：数据元素同属一个集合。
基本操作P：Create(&ST,n);操作结果：构造一个含n个数据元素的静态查找表ST。
Destroy(&ST);初始条件：静态查找表ST存在。
操作结果：销毁表ST。
Search(ST,key);初始条件：静态查找表ST存在，key 为和关键字类型相同的给定值。
操作结果：若 ST 中存在其关键字等于key的数据元素，则函数值为其值或在表中的位置，否则为“空”。
Traverse(ST,Visit());初始条件：静态查找表ST存在，Visit是对元素操作的应用函数。
操作结果：按某种次序对ST的每个元素调用函数Visit()一次且仅一次。
一旦Visit()失败，则操作失败。
}ADT StaticSearchTable2．存储结构定义*公用头文件DS0.h:#include<stdio.h>#include<malloc.h>#include<math.h>*预定义常量和类型//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0typedef int Status;typedef int KeyType;typedef float KeyType;typedef char KeyType;typedef int ElemType;typedef ElemType TElemType;1)顺序存储结构typedef struct{ElemType *elem; //数据元素存储空间基址，0号单元留空int length; //表长}SSTable;2)二叉链表存储结构typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild; //左右孩子指针}BiTNode,*BiTree;3. 算法设计1)顺序表的查找void Creat_Seq(SSTable *ST,ElemType r[],int n){int i;(*ST).elem = (ElemType*)calloc(n+1,sizeof(ElemType)); //动态生成n+1个数据元素空间(0号单元不用)if(!(*ST).elem) exit(0);for(i=1;i<=n;i++)(*ST).elem[i]=r[i-1]; //将数组r的值依次赋给ST(*ST).length=n;}Status Destroy_Seq(SSTable &ST){free(ST.elem);ST.elem = NULL;ST.length = 0;return OK;}int Search_Seq(SSTable ST,KeyType key){int i;ST.elem[0].key=key; //哨兵for(i=ST.length;!(ST.elem[i].key==key);--i); //从后往前找return i; //找不到时，i为0}void Traverse(SSTable ST,void(*Visit)(ElemType)){ElemType *p;int i;p=++ST.elem; //p指向第一个元素for(i=1;i<=ST.length;i++)Visit(*p++);}2)有序表的查找int Search_Bin(SSTable ST,KeyType key){int low,high,mid;low = 1;high = ST.length; //置区间初值while(low<=high){mid = (low + high)/2;if(key==ST.elem[mid]) return mid; //找到待查元素else if(key<ST.elem[mid]) high = mid - 1;/*继续在前半区间查找*/else low = mid + 1; //继续在后半区间查找}return 0; //查找失败}3)静态树表的查找Status Creat_Seq(SSTable *ST,int n){int i;(*ST).elem = (ElemType*)calloc(n+1,sizeof(ElemType)); //动态生成n+1个数据元素空间(0号单元不用)if(!(*ST).elem) exit(0);for(i=1;i<=n;i++)(*ST).elem[i]=r[i-1]; //将数组r的值依次赋给ST(*ST).length=n;return OK;}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((*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];}}}Status Creat_Ord(SSTable *ST,int n){Status f;f=Creat_Seq(ST,n);if(f)Ascend(ST);return f;}Status SecondOptimal(BiTree *T, ElemType R[],int sw[],int low,int high){ int i,j;double min,dw;i=low;min=fabs(sw[high]-sw[low]);dw=sw[high]+sw[low-1];for(j=low+1;j<=high;++j) //选择最小值if(fabs(dw-sw[j]-sw[j-1])<min){i=j;min=fabs(dw-sw[j]-sw[j-1]);}*T=(BiTree)malloc(sizeof(BiTNode));if(!*T)return ERROR;(*T)->data=R[i]; //生成结点if(i==low)(*T)->lchild=NULL; //左子树空elseSecondOptimal(&(*T)->lchild,R,sw,low,i-1); //构造左子树if(i==high)(*T)->rchild=NULL;elseSecondOptimal(&(*T)->rchild,R,sw,i+1,high);return OK;}Status Traverse(SSTable ST,void(*Visit)(ElemType)){ElemType *p;int i;p=++ST.elem; // p指向第一个元素for(i=1;i<=ST.length;i++)Visit(*p++);return OK;}void FindSW(int sw[],SSTable ST){int i;sw[0]=0;for(i=1;i<=ST.length;i++)sw[i]=sw[i-1]+ST.elem[i].weight;}typedef BiTree SOSTree;Status CreateSOSTree(SOSTree *T,SSTable ST) {if(ST.length==0)*T=NULL;else{FindSW(sw,ST);SecondOptimal(T,ST.elem,sw,1,ST.length); }return OK;}Status Search_SOSTree(SOSTree *T,KeyType key) {while(*T)if((*T)->data.key==key)return OK;else if((*T)->data.key>key)*T=(*T)->lchild;else*T=(*T)->rchild;return FALSE;}4．测试：1）顺序表的查找typedef struct{ //数据元素long number; //准考证号char name[9];int politics;int Chinese;int English;int math;int physics;int chemistry;int biology;int total; //总分}ElemType; //以教科书图9.1高考成绩为例void print(ElemType c){printf("%-8ld%-8s%4d%5d%5d%5d%5d%5d%5d%5d\n",c.number,,c.po litics,c.Chinese,c.English,c.math,c.physics,c.chemistry,c.biology,c.t otal);}SSTable head;int main(){ElemType r[N]={{179325,"陈红",85,86,88,100,92,90,45},{179326,"陆华",78,75,90,80,95,88,37},{179327,"张平",82,80,78,98,84,96,40}};SSTable st;int i;long s;for(i=0;i<N;i++) //计算总分r[i].total=r[i].politics+r[i].Chinese+r[i].English+r[i].math+r[i].physics+r[i].chemistry+r[i].biology;Creat_Seq(&st,r,N);printf("准考证号姓名政治语文外语数学物理化学生物总分\n");Traverse(st,print);printf("请输入待查找人的考号: ");scanf("%ld",&s);i=Search_Seq(st,s);if(i)print(st.elem[i]);elseprintf("查找失败\n");}结果截图如下：<1>查找成功：<2>查找失败：2）有序表的查找SSTbale head;int main(){int j,k,t,w;SSTable ST;int i;ST.length=LENGTH;printf("请按大小顺序输入一个顺序表共%d个元素!\n",ST.length);ST.elem=(ElemType*)malloc((ST.length+1)*sizeof(ElemType));for(i=1;i<=ST.length;i++)scanf("%d",&ST.elem[i]);printf("请输入要查找的元素：");scanf("%d",&k);w=Search_Bin(ST,k);if(w)printf("您要查找的%d是第%d个元素\n",k,w);else printf("查找失败\n");}结果截图如下：<1>查找成功：<2>查找失败：3）静态树链表的查找typedef struct{ //数据元素类型KeyType key;int weight;}ElemType;ElemType r[M]={{'A',1},{'B',1},{'C',2},{'D',5},{'E',3},{'F',4},{'G',4},{'H',3},{'I',5}};//以教科书例9-1为例void print(ElemType c) /* Traverse()调用的函数 */{printf("(%c %d) ",c.key,c.weight);}SSTbale head;int main(){SSTable st;SOSTree t;Status i;KeyType s;Creat_Ord(&st,M); /* 由全局数组产生非降序静态查找表st */ Traverse(st,print);CreateSOSTree(&t,st); /* 由有序表构造一棵次优查找树 */printf("\n请输入待查找的字符: ");scanf("%c",&s);i=Search_SOSTree(&t,s);if(i)printf("%c的权值是%d\n",s,t->data.weight);elseprintf("表中不存在此字符\n");}结果截图如下：<1>查找成功：<2>查找失败：三、实验总结和体会1.几种存储结构的比较1)顺序查找：优点：算法简单且适应面广；缺点：平均查找长度较大，特别是当n很大时，查找效率较低。
