数据结构C语言版上机实验报告——折半查找
数据结构C语言实现顺序查找,折半查找,二叉排序树,哈希表实验原理(实验原理+程序代码+程序截图+实验小结
printf("top=%d, bottom=%d, mid=%d, a[%d]=%d\n",top,bottom,mid,mid,a[mid]);
if( (num>a[top]) || (num<a[bottom]) ) //输入的数num>a[top]或者num<a[bottom]，肯定num不在这个表列中
学号：E30814013专业：网络工程姓名：张芸
实验日期：2010-6-12教师签字：成绩
实验报告
实验目的：实现顺序查找，折半查找，二叉排序树，哈希表实验原理：
顺序查找
int Search_Seq(SSTable ST, KeyType key) { //算法9.1
//在顺序表ST中顺序查找其关键字等于key的数据元素。
}
else
{
if (NULL == cursor->rchild)
{
cursor->rchild = node;
break;
}
cursor = cursor->rchild;
}
}
}
return;
}
/*查找指定值*/
BSTree Search(BSTree tree, ElemType item)
{
BSTree cursor = tree;
// p返回的是插入位置
} // SearchHash
顺序查找
#include<stdio.h>
void main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10};
int i,x,y;
printf("输入你要查找的数:\n");
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的：掌握几种基本的数据结构：集合、线性结构、树形结构等在求解实际问题中的应用，以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材：数据结构题集（C语言版）清华大学出版社2007年实验项目：实验一、栈和循环队列㈠、实验内容：①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。
本程序采用的是链栈结构，具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，学会循环队列的实现，以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码：#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果：②循环队列程序代码：#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为：\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为：\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果：实验二、数组㈠、实验内容：数组一般不做插入或删除操作，也就是说，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。
实验六 折半和二叉排序树查找实验
软件学院数据结构实验报告2012 ～2013 学年第一学期 2011 级水利信息管理专业班级：学号：姓名：实验六查找算法实验一、实验目的1、掌握静态查找表的查找算法2、掌握二叉排序树的查找算法3、掌握哈希函数的构造和哈希表的查找4、了解查找表的广泛应用二、实验内容1、有序表的查找1.1 数据结构的设计有序表的存储结构（数组表示)#define Max 20int a[Max] = {05,13,19,21,37,56,64,75,80,88,92}1.2 基本思想：折半查找算法在有序表中，取中间的记录作为比较对象，如果要查找记录的关键字等于中间记录的关键字，则查找成功；若要查找记录的关键字小于中间记录的关键字，则在中间记录的左半区继续查找；若要查找记录的关键字大于中间记录的关键字，则在中间记录的右半区继续查找。
不断重复上述查找过程，直到查找成功，或有序表中没有所要查找的记录，查找失败。
例：输入：查找记录的关键字 k = 13，k =37，k =99输出：k=13，查找成功；k=37，查找成功；k=99，查找不成功1.3 实验步骤：源程序：1.4 运行结果：2、二叉排序树的查找2.1 数据结构的设计二叉链表的存储结构表示：typedef int datatype;struct bi_search_tree{datatype key;struct bi_search_tree *left, *right;}bst_tree;2.2 基本思路先将输入的数据记录序列通过二叉排序树的插入算法建立一个二叉排序树，然后在二叉排序树中查找某个给定的关键字，返回查找成功或者不成功的结果输入：（1）数据记录序列{37,56,05,13,19,21, 64, 88, 75,80,92}建立二叉排序树，（2）查找记录的关键字 k = 13，k =37，k =99输出：k=13，查找成功；k=37，查找成功；k=99，查找不成功2.3 实验步骤：主要函数声明：主函数代码：2.4 运行结果：三、问题讨论1、折半查找有哪些特点？2、二叉排序树有那些特点？四、实验心得实验源码：（折半查找）#include <stdio.h>#define LENGTH 20void Search(int *fp,int data,int length);void main(){int count,i,choise;int arr[LENGTH];printf("请输入你的数据的个数:\n");scanf("%d",&count);printf("请输入%d个有序的数据\n",count);for(i=0;i<count;i++){scanf("%d",&arr[i]);}printf("请输入你要查找的数据:\n");scanf("%d",&choise);Search(arr,choise,count);}void Search(int *fp,int data,int length){int i=0;int low,high,middle;low=0; high=length;while (low<=high){middle=(low+high)/2;i++;if(fp[middle]<data){low=middle+1;}else if(fp[middle]>data){high=middle-1;}else{printf("经过%d次查找，查找到数据:%d.\n",i,data);return;}}printf("经过%d次查找，未能查找到数据:%d.\n",i,data);}二叉排序树：#include <stdio.h>#include <stdlib.h>#include <string.h>#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)< (b))#define LQ(a,b) ((a)<=(b))#define TRUE 1#define FALSE 0#define OVERFLOW -2typedef int KeyType;typedef int Status;typedef struct{KeyType key; /*关键字域*/}SElemType;typedef struct BitNode{SElemType data; /*存储空间基址,建表时按实际长度分配，0号单元留空*/ struct BitNode *lchild,*rchild;}BitNode,* BiTree;/*二叉排序树的插入*/Status InsertBST(BiTree T, KeyType key){BiTree s;if(!T){s=(BiTree)malloc(sizeof(BitNode));s->data.key=key;s->lchild=s->rchild=NULL;T=s;}else if LT(key,T->data.key)InsertBST(T->lchild,key);else InsertBST(T->rchild,key);return TRUE;}/*创建二叉排序树*/void CreateBST(BiTree T){KeyType key;T=NULL;scanf("%d",&key);while(key!=0){InsertBST(T,key);scanf("%d",&key);}}/*中序遍历*/void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);printf("%4d",T->data.key);InOrderTraverse(T->rchild);}}/*打印二叉树*/Status PrintTree(BiTree T,int n){int i=0;if(T == NULL)return FALSE;PrintTree(T->rchild,n+1);for(i=0;i<n;i++)printf(" ");printf("%d\n",T->data.key);PrintTree(T->lchild,n+1);return TRUE;}/*二叉排序树的查找*/BiTree SearchBST(BiTree T,KeyType key){if(!T){printf("Can not find!!\n");return T;}else if EQ(key,T->data.key){return T;}else if LT(key,T->data.key) return SearchBST(T->lchild,key); else return SearchBST(T->rchild,key);}/*二叉排序树的删除*/Status Delete(BiTree p){BiTree q,s;if(!p->rchild){q=p;p=p->lchild;free(q);}else if(!p->lchild){q=p;p=p->rchild;free(q);}else{q=p;s=p->lchild;while(s->rchild){q=s;s=s->rchild;}p->data=s->data;if(q!=p) q->rchild=s->lchild;else q->lchild=s->lchild;// delete s;}return TRUE;}Status DeleteBST(BiTree T,KeyType key){if(!T)return FALSE;else{if (EQ(key,T->data.key))return Delete(T);elseif(LT(key,T->data.key))return DeleteBST(T->lchild,key);else return DeleteBST(T->rchild,key);}}void main() {BiTree b1,b2;KeyType key;int t;begin:printf("1:创建二叉排序树\n");printf("2:打印排序树\n");printf("3:查找结点\n");printf("4:中序遍历\n");printf("5:插入结点\n");printf("6:删除结点\n");printf("0:退出\n");printf("请选择要进行的操作:");scanf("%d",&t);switch(t){case 1:printf("Input every key (0 to quit):");CreateBST(b1);PrintTree(b1,0);//排序树的结果打印出来goto begin;case 2:PrintTree(b1,0);goto begin;case 3:printf("Input the key to search:");scanf("%d",&key);if(key!=0){b2=SearchBST(b1,key);//把 key 为根的子树打印出来PrintTree(b2,0);printf("\nThe root is the key to search!!\n\n");}else printf("Can not find!!\n");goto begin;case 4:InOrderTraverse(b1);goto begin;case 5:printf("输入要插入的数据：");scanf("%d",&key);if(InsertBST(b1, key))printf("\n插入完毕！\n");else printf("插入失败\n");goto begin;case 6:printf("输入要删除的数据：");scanf("%d",&key);if(DeleteBST(b1, key))printf("\n删除完毕！\n");else printf("删除失败\n");goto begin;case 0: break;default: printf("输入错误\n");}}。
数据结构实验指导书(新版)
《数据结构和算法》实验指导书实验及学时数分配序号实验名称学时数（小时）1 实验一线性表 42 实验二树和二叉树 23 实验三图 24 实验四查找 25 实验五内部排序 2合计12几点要求：一、上机前：认真预习相关实验内容，提前编写算法程序，上机时检查（未提前编写程序者，扣除平时成绩中实验相关分数）。
二、上机中：在Turbo C或VC6.0环境中，认真调试程序，记录调试过程中的问题、解决方法以及运行结果。
上机时签到；下机时验收签字。
三、下机后：按要求完成实验报告，并及时提交（实验后1周内）。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现；2、单链表的插入、删除操作的实现；3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个元素之后的所有元素依次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置；2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时，只需先确定第i个元素前一个元素位置，然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时，也必须先确定第i个元素前一个元素位置，然后修改相应指针将该元素删除即可；3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表，并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表；（从键盘接受元素个数n以及n个整形数；按一定格式显示所建立的线性表）2、指定一个元素，在此元素之前插入一个新元素；（从键盘接受插入位置i，和要插入的元素值；实现插入；显示插入后的线性表）3、指定一个元素，删除此元素。
数据结构——查找,顺序查找,折半查找
实验五查找的应用一、实验目的：1、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。
2、增强上机编程调试能力。
二、问题描述1.分别利用顺序查找和折半查找方法完成查找。
有序表（3,4,5,7,24,30,42,54,63,72,87,95）输入示例：请输入查找元素：52输出示例：顺序查找：第一次比较元素95第二次比较元素87 ……..查找成功，i=**/查找失败折半查找：第一次比较元素30第二次比较元素63 …..2.利用序列（12,7,17,11,16,2,13,9,21,4）建立二叉排序树，并完成指定元素的查询。
输入输出示例同题1的要求。
三、数据结构设计（选用的数据逻辑结构和存储结构实现形式说明）（1）逻辑结构设计顺序查找和折半查找采用线性表的结构，二叉排序树的查找则是建立一棵二叉树，采用的非线性逻辑结构。
（2）存储结构设计采用顺序存储的结构，开辟一块空间用于存放元素。
（3）存储结构形式说明分别建立查找关键字，顺序表数据和二叉树数据的结构体进行存储数据四、算法设计（1）算法列表（说明各个函数的名称，作用，完成什么操作）序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化，并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 （2）各函数间调用关系（画出函数之间调用关系）typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;（3）算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
数据结构实验折半查找C语言实现
#include<stdio.h>#include<stdlib.h>#include <conio.h>#define overflow -1#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))#define LQ(a,b) ((a)<=(b))//--------------------------折半查找的数据结构------------------------typedef intKeyType;typedef struct{KeyType key;}ElemType;typedef struct{ElemType *elem;int length;}SST able;//---------------------------操作函数-----------------------------------void InitList(SSTable&ST,KeyType n);//静态查找表的初始化void createSST able(SST able&ST);//向查找表中输入元素void print(SST able ST);intsearch_Seq(SSTableST,KeyType key);void SortSST able(SSTable&ST);intSearch_Bin(SSTableST,KeyType key);//---------------------------算法实现-----------------------------------////////////////////////////静态查找表的初始化,查找表长度为n/////////////////////////// void InitList(SSTable&ST,int n){ST.elem=(ElemType *)malloc((n+1)*sizeof(KeyType));if(!ST.elem)exit(overflow);ST.length=n;}////////////////////////////向查找表中输入元素///////////////////////////void createSST able(SST able&ST){int a;printf("要向查找表中输入多少元素？\n");scanf("%d", &a);printf("向查找表中输入元素\n");for(inti=1;i<=a;i++)scanf("%d",&(ST.elem[i].key));ST.length=a;}///////////////////////////显示查找表里的元素//////////////////////////// void print(SST able ST){inti;printf("查找表中元素是:\n ");for(i=1;i<=ST.length;i++)printf("%d ",ST.elem[i].key);printf("\n");}//////////////////////////查找元素key///////////////////////////////////// intsearch_Seq(SSTableST,KeyType key){inti;ST.elem[0].key=key;for(i=ST.length;!EQ(ST.elem[i].key,key);--i);return i;}/////////////////////////对查找表元素进行排序///////////////////////////// void SortSST able(SSTable&ST){for(inti=1;i<ST.length-1;i++)for(int j=1;j<=ST.length-i;j++){if(ST.elem[j].key>ST.elem[j+1].key){int temp=ST.elem[j].key;ST.elem[j].key=ST.elem[j+1].key;ST.elem[j+1].key=temp;}}}////////////////////////////////折半查找/////////////////////////////// intSearch_Bin(SSTableST,KeyType key){intlow,mid,high;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(EQ(key,ST.elem[mid].key))return mid;else if (LT(key,ST.elem[mid].key))high=mid-1;elselow=mid+1;}return 0;}//--------------------------------主函数---------------------------------void main(){SSTable ST;printf(" 请输入要建立的查找表的长度:");int n;scanf("%d",&n);InitList(ST,n);printf("\n\n\n 查找表已建立，您可以选择下面您要进行的操作：");printf("\n**************************************************************************");printf(" \n 1:向查找表中输入元素2:显示查找表里的元素\n");printf(" 3:查找元素key 4:对查找表元素进行排序\n");printf(" 5:排序后进行折半查找6：清屏！选其他任意键结束！\n"); printf("**************************************************************************\n");inti;begin:printf("请输入选项：");scanf("%d",&i);printf("\n");switch(i){case 1: createSSTable(ST);printf("输入完毕！\n");goto begin;case 2:print(ST); printf(""); goto begin;case 3:printf("请输入你要查找的元素\n");int key;scanf("%d",&key);intinput_key;input_key=search_Seq(ST,key);if(input_key==0)printf("元素%不在查找表中！\n",key);elseprintf("元素%d是查找表中第%d个元素\n",ST.elem[input_key].key,input_key); goto begin;case 4:printf("排序后");SortSSTable( ST );print(ST);goto begin;case 5:printf("请输入你要查找的数字\n");scanf("%d",&key);input_key=Search_Bin(ST,key);if(input_key==0)printf("利用折半查找法没有找到元素%c！\n",key);else{ printf("利用折半查找法得到的查找结果：\n");printf("%d是查找表中第%d个元素\n",ST.elem[input_key].key,input_key); } goto begin;case 6: system("cls");default: break;}}。
数据结构查找算法实验报告
数据结构实验报告实验第四章：实验：简单查找算法一．需求与规格说明：查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找与哈希表查找四种方法。
由于自己能力有限,本想实现其她算法,但没有实现.其中顺序查找相对比较简单,折半查找参考了书上得算法，二叉排序树查找由于有之前做二叉树得经验，因此实现得较为顺利，哈希表感觉做得并不成功，感觉还就是应该可以进一步完善，应该说还有很大得改进余地。
二．设计思想:开始得时候提示输入一组数据。
并存入一维数组中，接下来调用一系列查找算法对其进行处理。
顺序查找只就是从头到尾进行遍历。
二分查找则就是先对数据进行排序，然后利用三个标志，分别指向最大，中间与最小数据，接下来根据待查找数据与中间数据得比较不断移动标志，直至找到。
二叉排序树则就是先构造,构造部分花费最多得精力,比根节点数据大得结点放入根节点得右子树，比根节点数据小得放入根节点得左子树，其实完全可以利用递归实现，这里使用得循环来实现得,感觉这里可以尝试用递归.当二叉树建好后，中序遍历序列即为由小到大得有序序列，查找次数不会超过二叉树得深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则就是利用给定得函数式建立索引,方便查找.三．设计表示:四．实现注释:其实查找排序这部分与前面得一些知识联系得比较紧密，例如顺序表得建立与实现，顺序表节点得排序,二叉树得生成与遍历，这里主要就是中序遍历.应该说有些知识点较为熟悉,但在实现得时候并不就是那么顺利。
在查找到数据得时候要想办法输出查找过程得相关信息，并统计。
这里顺序查找与折半查找均使用了数组存储得顺序表，而二叉树则就是采用了链表存储得树形结构。
为了直观起见，在用户输入了数据后,分别输出已经生成得数组与树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计.二叉排序树应该说由于有了之前二叉树得基础，并没有费太大力气,主要就是在构造二叉树得时候，要对新加入得节点数据与跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构实验报告折半查找
数据结构实验报告折半查找1. 引言数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织方式、存储结构和算法设计等内容。
在数据结构中，折半查找（Binary Search）是一种常用的查找算法，可以在有序的数据集合中快速找到目标元素。
本实验报告将介绍折半查找算法的原理、实现过程以及在不同数据规模下的性能分析。
2. 折半查找原理折半查找是一种分而治之的算法，通过比较目标元素与中间元素的大小关系，不断将待查找范围缩小一半，并在所需的时间内逐步逼近目标元素。
具体的折半查找算法如下：1. 设置左边界l和右边界r，初始时l=0，r=n-1（n为数据集合的长度）；2. 计算中间元素的下标mid = (l + r) / 2；3. 比较目标元素与中间元素的值，若相等，则返回目标元素的下标；4. 若目标元素小于中间元素的值，则将右边界r更新为mid-1；5. 若目标元素大于中间元素的值，则将左边界l更新为mid+1；6. 重复步骤2-5，直到找到目标元素或区间缩小为空。
折半查找的时间复杂度为O(log n)，比顺序查找的时间复杂度O(n)要小得多。
3. 折半查找的实现实现折半查找的关键就是要确定好左边界l和右边界r的初始值，并在每个循环中更新这两个边界的值。
下面是使用Python语言实现折半查找的代码示例：```pythondef binary_search(arr, target):l = 0r = len(arr) - 1while l <= r:mid = (l + r) // 2if arr[mid] == target:return midelif arr[mid] < target:l = mid + 1else:r = mid - 1return -1```在上述代码中，我们通过设置左边界l和右边界r来确定待查找范围。
通过不断更新这两个边界的值，最终可以找到目标元素的位置。
如果找不到目标元素，则返回-1表示查找失败。
数据结构实验指导书(新版)
《数据结构与算法》实验指导书实验及学时数分配几点要求：一、上机前：认真预习相关实验内容，提前编写算法程序，上机时检查（未提前编写程序者，扣除平时成绩中实验相关分数）。
二、上机中：在Turbo C或VC6.0环境中，认真调试程序，记录调试过程中的问题、解决方法以及运行结果。
上机时签到；下机时验收签字。
三、下机后：按要求完成实验报告，并及时提交（实验后1周内）。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现；2、单链表的插入、删除操作的实现；3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个元素之后的所有元素依次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置；2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时，只需先确定第i个元素前一个元素位置，然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时，也必须先确定第i个元素前一个元素位置，然后修改相应指针将该元素删除即可；3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表，并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表；（从键盘接受元素个数n以及n个整形数；按一定格式显示所建立的线性表）2、指定一个元素，在此元素之前插入一个新元素；（从键盘接受插入位置i，和要插入的元素值；实现插入；显示插入后的线性表）3、指定一个元素，删除此元素。
（从键盘接受删除元素位置i，实现删除；显示删除后的线性表）二、用C语言编程实现建立一个单链表，并在此表中插入一个元素和删除一个元素。
《C语言》上机实验题及参考答案
《C语言》上机实验题及参考答案作者名：不详来源：网友提供05年7月21日1、编程实现对键盘输入的英文名句子进行加密。
用加密方法为，当内容为英文字母时其在26字母中的其后三个字母代替该字母，若为其它字符时不变：2、编程实现将任意的十进制整数转换成R进制数（R在2-16之间）。
3、从键盘输入一指定金额（以元为单位，如345.78），然后显示支付该金额的各种面额人民币数量，要求显示100元、50元、10元、5元、2元、1元、1角、5分、1分各多少张。
4、随机产生20个[10，50]的正整数存放到数组中，并求数组中的所有元素最大值、最小值、平均值及各元素之和。
5、编程在一个已知的字符串中查找最长单词，假定字符串中只含字母和空格，空格用来分隔不同单词。
6、模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用A、B、C、D表示，当选某候选人时直接输入其编号(编号由计算机随机产生)，若输入的不是A、B、C、D则视为无效票，选举结束后按得票数从高到低输出候选人编号和所得票数。
7、任何一个自然数m的立方均可写成m个连续奇数之和。
例如：1^3=12^3=3+53^3=7+9+114^3=13+15+17+19编程实现：输入一自然数n，求组成n3的n个连续奇数。
8、已知abc+cba=1333，其中a,b,c均为一位数，编程求出满足条件的a,b,c所有组合。
9、编制一个完成两个数的四则运算程序。
如：用户输入34+56则输出结果90.00。
要求运算结果保留两位小数，用户输入时一次将两个数和操作符输入。
10、输入一个五位以内的正整数，（1）判断它是一个几位数；（2）请按序输出其各位数字；（3）逆序输出其各位数字。
如输入：56439，输出：5位数5，6，4，3，99，3，4，6，511、编写子函数：（1）用冒泡法将一个数组排成升序的函数---SUB1；（2）在升序数组中插入一个数，并且保持该数组仍为升序数组的函数---SUB2。
数据结构实验---折半查找实验报告
深圳大学实验报告课程名称：数据结构实验项目名称：查找排序之折半查找学院：信息工程学院专业：电子信息工程指导教师：报告人：学号：2009100000 班级：电子1班实验时间：2011年12月2日实验报告提交时间：2011年12月13日教务处制//调用函数Search_Bin，并将函数返回结果放在i中i = Search_Bin(Data, Dnum, skey);printf("----------------------------------------\n");if(i==-1) //若Search_Bin返回值为-1则显示查找失败printf("查找失败!\n");else //不然则执行下面语句{printf("查找成功!\n");printf("查找的数据位置在(%d)\n",i);}printf("查找次数(%d)",icount);printf("\n");return 0;}四、实验结论：实结果图：情况一、能够在待查数组中查找到待查元素情况二、不能够在待查数组中查找到待查元素数据分析基于上面程序运行图可以很明显得知整个算法的实现过程，针对第一个图：1、首先建立一个数组存放待查元素2、针对定值key进行折半查找，第一个图可以得到key=113、mid=（low+high）/2 =（0+5）/2 =2.得到的是ST[2]=33,查找了一次4、判断ST[2]=33大于key=11，即执行high=mid-1=15、mid=（low+high）/2 =（0+1）/2 =0.得到的是ST[0]=11=key，查找成功，查找了两次6、返回待查元素所在位置7、同理。
若查找不成功则返回查找失败五、实验体会：本次实验很简单，只要掌握折半查找算法的原理，那么剩下的就是花时间编写代码和调试程序。
折半查找算法_实验报告
一、实验目的1. 理解折半查找算法的基本原理和实现方法。
2. 掌握在C语言中实现折半查找算法的技巧。
3. 比较折半查找算法与其他查找算法（如顺序查找）的性能差异。
4. 应用折半查找算法解决实际问题。
二、实验环境1. 编程语言：C语言2. 开发环境：Visual Studio Code3. 操作系统：Windows 10三、实验原理折半查找算法，又称二分查找算法，是一种在有序数组中查找特定元素的查找方法。
其基本原理如下：1. 将查找的有序数组分为左右两部分。
2. 比较查找元素与中间元素的大小关系。
3. 如果查找元素等于中间元素，则查找成功。
4. 如果查找元素小于中间元素，则在左半部分继续查找。
5. 如果查找元素大于中间元素，则在右半部分继续查找。
6. 重复步骤2-5，直到找到目标元素或查找范围为空。
四、实验内容1. 实现折半查找算法。
2. 比较折半查找算法与顺序查找算法的性能。
3. 应用折半查找算法解决实际问题。
五、实验步骤1. 创建一个有序数组。
2. 输入要查找的元素。
3. 使用折半查找算法查找目标元素。
4. 输出查找结果。
六、实验代码```c#include <stdio.h>// 折半查找算法int binary_search(int arr[], int left, int right, int target) { while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {return mid; // 找到目标元素，返回索引} else if (arr[mid] < target) {left = mid + 1; // 在右半部分查找} else {right = mid - 1; // 在左半部分查找}}return -1; // 未找到目标元素}int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int n = sizeof(arr) / sizeof(arr[0]);int target;printf("请输入要查找的元素：");scanf("%d", &target);int index = binary_search(arr, 0, n - 1, target);if (index != -1) {printf("找到元素 %d 在数组中的位置：%d\n", target, index);} else {printf("未找到元素 %d\n", target);}return 0;}```七、实验结果与分析1. 折半查找算法的时间复杂度为O(log2n)，而顺序查找算法的时间复杂度为O(n)。
(完整word版)数据结构(c语言版)课后习题答案完整版资料
第1章绪论5．选择题：CCBDCA6．试分析下面各程序段的时间复杂度。
（1)O（1）（2）O(m＊n）（3）O（n2）（4)O（log3n）（5)因为x++共执行了n—1+n—2+……＋1= n(n—1)/2，所以执行时间为O(n2)（6）O(n）第2章线性表1．选择题babadbcabdcddac2．算法设计题(6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
ElemType Max （LinkList L ）｛if(L—〉next==NULL) return NULL；pmax=L-〉next；//假定第一个结点中数据具有最大值p=L-〉next—>next；while(p ！= NULL ){//如果下一个结点存在if（p->data > pmax—>data) pmax=p；p=p->next；｝return pmax-〉data;（7)设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间.void inverse(LinkList ＆L) ｛// 逆置带头结点的单链表Lp=L-〉next；L->next=NULL；while （p）｛q=p—>next；// q指向＊p的后继p->next=L—>next;L—>next=p; // *p插入在头结点之后p = q;｝}（10)已知长度为n的线性表A采用顺序存储结构,请写一时间复杂度为O(n)、空间复杂度为O（1）的算法，该算法删除线性表中所有值为item的数据元素.［题目分析］在顺序存储的线性表上删除元素,通常要涉及到一系列元素的移动（删第i个元素，第i+1至第n个元素要依次前移)。
本题要求删除线性表中所有值为item的数据元素，并未要求元素间的相对位置不变。
因此可以考虑设头尾两个指针（i=1，j=n）,从两端向中间移动，凡遇到值item的数据元素时，直接将右端元素左移至值为item的数据元素位置。
数据结构实验报告-BST存储结构与折半查找
实验报告课程名称：数据结构与算法课程类型：必修实验项目：树型查找结构与排序方法实验题目：BST存储结构与折半查找一、实验目的1. 理解二叉查找树的存储结构。
2. 掌握BST的插入、删除、查找、排序等多种算法。
3. 掌握折半查找算法。
4. 学会计算BST的查找成功及失败的平均查找长度。
5. 学会计算折半查找的查找成功及失败的平均查找长度。
二、实验要求及实验环境实验要求：1. 设计BST 的左右链存储结构，并实现BST插入（建立）、删除、查找和排序算法。
2. 实现折半查找算法。
3. 实验比较：设计并产生实验测试数据，考察比较两种查找方法的时间性能，并与理论结果进行比较。
以下具体做法可作为参考：4. 第1组测试数据： n=1024个已排序的整数序列（如0至2048之间的奇数）；第2组测试数据：第1组测试数据的随机序列。
5. 按上述两组序列的顺序作为输入顺序，分别建立BST。
6. 编写程序计算所建的两棵BST的查找成功和查找失败的平均查找长度（主要是改造Search算法，对“比较”进行计数），并与理论结果比较。
7. 以上述BST的中序遍历序列作为折半查找的输入，编写程序分别计算折半查找的查找成功和查找失败的平均查找长度，并与理论结果比较。
8. 以上实验能否说明：就平均性能而言，BST的查找与折半查找差不多，为什么？实验环境：codeblocks/Dev-C++三、设计思想（本程序中的用到的所有数据抽象数据性ADT的定义，主程序的流程图及各程序模块之间的调用关系）1. 所用的抽象数据性ADT的定义1）逻辑结构：BST树：二叉查找树是一个满足以下条件的树：任意一个结点的关键字，都大于(小于)其左(右)子树中任意结点的关键字，因此各结点的关键字互不相同按中序遍历二叉查找树所得的中序序列是一个递增的有序序列，因此，二叉查找树可以把无序序列变为有序序列。
同一个数据集合，可按关键字表示成不同的二叉查找树，即同一数据集合的二叉查找树不唯一；但中序序列相同。
数据结构(c语言版)课后习题答案完整版
第1章绪论5．选择题：CCBDCA6．试分析下面各程序段的时间复杂度。
（1）O（1）（2）O（m*n）（3）O（n2）（4）O（log3n）（5）因为x++共执行了n-1+n-2+……＋1= n(n-1)/2，所以执行时间为O（n2）（6）O(n)第2章线性表1．选择题babadbcabdcddac2．算法设计题（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。
ElemType Max (LinkList L ){if(L->next==NULL) return NULL;pmax=L->next; //假定第一个结点中数据具有最大值p=L->next->next;while(p != NULL ){//如果下一个结点存在if(p->data > pmax->data) pmax=p;p=p->next;}return pmax->data;（7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。
void inverse(LinkList &L) {// 逆置带头结点的单链表 Lp=L->next; L->next=NULL;while ( p) {q=p->next; // q指向*p的后继p->next=L->next;L->next=p; // *p插入在头结点之后p = q;}}（10）已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为item的数据元素。
[题目分析] 在顺序存储的线性表上删除元素，通常要涉及到一系列元素的移动（删第i个元素，第i+1至第n个元素要依次前移）。
本题要求删除线性表中所有值为item的数据元素，并未要求元素间的相对位置不变。
因此可以考虑设头尾两个指针（i=1，j=n），从两端向中间移动，凡遇到值item的数据元素时，直接将右端元素左移至值为item的数据元素位置。
C语言实验报告实验五参考答案
C语言实验报告实验五参考答案实验五一维数值数组（参考答案）1、设计程序sy5-1.c，计算n门课程的平均分。
例如：若有5门课程的成绩是：90.5.72.80.61.5.55，则平均分是：71.80.算法分析：先求n门课的成绩总和，（累加求和），再用累和除以课程数。
参考答案：includevoid main()double score[30]。
sum=0,aver;int n,i;printf("Inputn:");scanf("%d",&n);printf("请依次输入%d门课程的成绩",n);for(i=0;i<n;i++)scanf("%lf",&score[i]);sum=sum+score[i];aver=sum/n;printf( "\nAverage scoreis: %5.2f\n"。
aver);运行结果：2、设计步伐sy5-2.c，对输入的10个整数按倒序寄存后输出成效。
算法阐发：利用“半数交流”算法，最前面的元素和末了面的元素交流，逐步向中央挨近。
可利用两个下标变量i和XXX。
参考答案：includeint main()int a[10]={1,2,3,4,5,6,7,8,9,10};int i,j,t;for( i=0,j=9.i<j。
i++,j--)//逐一向中，交换。
直到已没有元素没交换t=a[i]。
a[i]=a[j]。
a[j]=t;}// a[i]-数组前端的数，a[j]-数组后端的数printf("交流后数组元素是：");for(i=0;i<10;i++)printf("%5d",a[i]);//%5d,5透露表现宽度printf("\n");//输出完所有的数后换行return 0;运行结果：3、设计程序sy5-3.c，输入10个整数，找出其中的最大数及其所在的下标。
折半查找_数据结构（C语言版）_[共3页]
![折半查找_数据结构（C语言版）_[共3页]](https://img.taocdn.com/s3/m/c92549ae168884868662d611.png)
if(ST.R[i].key==key) return i; //从后往前找return 0;}//Search _Seq 算法7.1在查找过程中每步都要检测整个表是否查找完毕，即每步都要有循环变量是否满足条件i >=1的检测。
改进这个程序，可以免去这个检测过程。
改进方法是查找之前先对ST.R[0]的关键字赋值key ，在此，ST.R[0]起到了监视哨的作用，如算法7.2所示。
算法7.2 设置监视哨的顺序查找【算法描述】int Search _Seq(SSTable ST,KeyType key){//在顺序表ST 中顺序查找其关键字等于key 的数据元素。
若找到，则函数值为//该元素在表中的位置，否则为0ST.R[0].key=key; //“哨兵”for(i=ST.length;ST.R[i].key!=key;--i); //从后往前找retutn i;}//Search _Seq 【算法分析】算法7.2仅是一个程序设计技巧上的改进，即通过设置监视哨，免去查找过程中每一步都要检测整个表是否查找完毕。
然而实践证明，这个改进能使顺序查找在ST.length ≥1000时，进行一次查找所需的平均时间几乎减少一半。
当然，监视哨也可设在高下标处。
算法7.2和算法7.1的时间复杂度一样，在第2章已经做过分析，即 1112n i n ASL i n =+==∑ 算法7.2的时间复杂度为O （n ）。
顺序查找的优点是：算法简单，对表结构无任何要求，既适用于顺序结构，也适用于链式结构，无论记录是否按关键字有序均可应用。
其缺点是：平均查找长度较大，查找效率较低，所以当n 很大时，不宜采用顺序查找。
7.2.2 折半查找折半查找（Binary Search ）也称二分查找，它是一种效率较高的查找方法。
但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
在下面及后续的讨论中，均假设有序表是递增有序的。
数据结构——折半查找源代码
数据结构折半查找源代码源代码：折半查找：#include<iostream.h>//cout,cin#include"process.h"//exit()#include"stdio.h"//EOF,NULLtypedef int T; //定义关键字的类型,这里就以整形来处理//查找表类定义template <class T>struct Node{T key; //关键字域/*........ //其他域,可以自己根据需要添加*/};template <class T>class SSearch {private:Node<T> *ST;int len;//表长public:SSearch();//~SSearch();//析构函数，删除表空间void Create(int n); //创建时根据用户实际需求,再为相应的数据元素赋值void Display(); //输出静态表中的数据元素int SeSearch(T key); //从表中最后一个元素开始顺序查找void Ascendsort(); //升序排列int BiSearch_1(T key);//折半查找，非递归算法int BiSearch_2(T key);//折半查找，递归算法int BiSearch2(int x,int y,T key);};template <class T>SSearch<T>::SSearch(){//ST=NULL;len=0;}template <class T>SSearch<T>::~SSearch(){//释放表空间delete [] ST;len=0;}template <class T>void SSearch<T>::Create(int n){len=n;ST=new Node<T>[len];Node<T> e;int i=0;cout<<"输入"<<len<<"个数据元素"<<endl;while(i<len){cin>>e.key;ST[i]=e;i++;}}template <class T>int SSearch<T>::SeSearch(T key){//从表中最后一个元素开始顺序查找，若找到，返回位序，否则，返回-1 for(int i=len-1;i>=0;i--)if(ST[i].key==key){cout<<"查找成功!位居第"<<i+1<<endl;return i;}cout<<"末找到!"<<endl;return -1;}template <class T>void SSearch<T>::Ascendsort(){T t;for(int i=0;i<len-1;i++){for(int j=0;j<len-i-1;j++)if(ST[j].key>ST[j+1].key){t=ST[j].key;ST[j].key=ST[j+1].key;ST[j+1].key=t;}}}template <class T>int SSearch<T>::BiSearch_1(T key){ //折半查找非递归算法if(len==0 && ST==NULL){cout<<"顺序表不存在,请先建立表\n";return -1;}else{int low=0,high=len-1;int mid;while(low<=high){mid=(high+low)/2;if(ST[mid].key==key){cout<<"找到!位居"<<mid+1<<endl;return mid;}if(ST[mid].key>key)high=mid-1;elselow=mid+1;}cout<<"末找到!"<<endl;return -1;}}template <class T>int SSearch<T>::BiSearch2(int x,int y,T key){//折半查找递归算法int mid=(x+y)/2;if(ST[mid].key==key)return mid;if(x>y)return -1; //表示没有找到if(key<ST[mid].key)return BiSearch2(x,mid-1,key);elsereturn BiSearch2(mid+1,y,key);}//template <class T>int SSearch<T>::BiSearch_2(T key){int k;k=BiSearch2(0,len-1,key);return k;}template <class T>void SSearch<T>::Display(){//输出静态表中的数据元素cout<<"静态表中的数据元素关键字依次为:\n";for(int i=0;i<len;i++){cout<<ST[i].key<<" ";}cout<<endl;}void main(){int choice,n,k;SSearch<int> a;cout<<"注意：必须先创建静态表)\n";cout<<"=======================\n";T key;cout<<"--- 1. 创建查找表------------------------\n"<<"--- 2. 顺序查找-------------------------\n"<<"--- 3. 折半查找<递归>----------------------\n"<<"--- 4. 折半查找<非递归> -------------------\n"<<"--- 5. 输出静态表中的所有数据元素关键字----\n"<<"--- 6. 退出------------------------- -----\n"; do{ cout<<"请选择操作:";cin>>choice;switch(choice){case 1://cout<<"输入静态查找表的长度"<<endl;cin>>n;a.Create(n);break;case 2://cout<<"请输入查找关键字："<<endl;cin>>key;a.SeSearch(key);break;case 3:a.Ascendsort();cout<<"输入查找关键字："<<endl;cin>>key;k=a.BiSearch_2(key);if(k==-1)cout<<"末找到!"<<endl;elsecout<<"找到!位居第"<<k+1<<endl;break;case 4:a.Ascendsort();cout<<"输入查找关键字："<<endl;cin>>key;a.BiSearch_1(key);break;case 5:a.Display();break;case 6:cout<<"运行结束"<<endl;break;default:cout<<"输入代码非法，应在0--7之间"<<endl;cout<<"请继续选择操作";break;}//switch}while(choice!=6); }//main。
折半查找及其改进(算法与数据结构课程设计)
折半查找及其改进一、问题描述查找是在一个数据元素集合中查找关键字等于某个给个数据元素关键字的过程，也称为检索。
给出一个特定的元素x，在含有n个元素的数列中判断是否存在这个元素，如果存在，返回此元素在数列中的位置，否则返回零。
数列查找在实际中的应用十分广泛，因此数列查找算法的好坏直接影响到程序的优劣。
本设计要求读取文件中的数据建立查找表,并设计算法实现折半查找及其改进查找。
二、基本要求1、选择合适的存储结构，读取已知文件数据建立查找表；2、完成基于递归和非逆归的折半查找算法的设计；3、完成基于区间约束对折半查找算法的改进算法的设计；4、完成三分查找算法的设计。
三、测试数据文件in.txt中100个数据：1,2,3…98,99,100。
1、读取文件in.txt中前50位数，查找元素:582、读取文件in.txt中前50位数，查找元素:183、读取文件in.txt中前100位数，查找元素：184、读取文件in.txt中前100位数，待查元素：58四、算法思想1、折半查找的算法思想是以处于区间中间位置记录的关键字和给定值比较，若相等，则查找成功，如不等，则缩小范围，直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
2、缩小区间查找算法的思想是先求出有序数列中每相邻两个元素之差的最大值的一个上界，设为m．要查找的数值为key，然后在每次循环做折半之前先进行一次筛选工作，即将low右移(key-a[low]/m)位，high值左移(a[high]-key)/m位，从而把尽可能多的不必要的元素过滤掉，缩小查找范围继续查找，直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
3、三分查找的算法思想是在给出n个已经排好序的数，在n/3和2n/3处各取一个数，跟给定值key比较，确定待查数所在的范围, 直至新的区间中间位置记录的关键字等于给定值或区间大小小于零时为止。
五、模块划分1、void read_dat(SSTable *ST,int n),读取文件in.dat中的数据并建立一个含文件in.dat中前n个数据的静态查找表ST。