数据结构实验---折半查找实验报告
折半查找法实验报告
1. 理解折半查找法的基本原理和适用条件。
2. 掌握折半查找法的实现方法。
3. 通过实验验证折半查找法的效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现折半查找法。
2. 对折半查找法进行测试，包括：a. 对已排序的数组进行查找；b. 对未排序的数组进行查找；c. 查找不存在的元素。
四、实验步骤1. 定义一个整型数组，并对其进行排序。
2. 实现折半查找函数，包括：a. 定义折半查找函数的参数，包括数组、目标值和数组的长度；b. 实现折半查找算法；c. 返回查找结果，包括找到的位置和未找到。
3. 对已排序的数组进行查找，输出查找结果。
4. 对未排序的数组进行查找，输出查找结果。
5. 对不存在的元素进行查找，输出查找结果。
```cpp#include <iostream>#include <algorithm>// 折半查找函数int binarySearch(const int arr, int target, int left, int right) { 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 = 11; // 目标值// 对数组进行排序std::sort(arr, arr + n);// 对已排序的数组进行查找int index = binarySearch(arr, target, 0, n - 1);if (index != -1) {std::cout << "已排序数组中找到目标值：" << target << "，位置为：" << index << std::endl;} else {std::cout << "已排序数组中未找到目标值：" << target << std::endl;}// 对未排序的数组进行查找int unsortedArr[] = {9, 5, 3, 7, 1, 11, 13, 17, 15, 19};int unsortedIndex = binarySearch(unsortedArr, target, 0, n - 1);if (unsortedIndex != -1) {std::cout << "未排序数组中找到目标值：" << target << "，位置为：" << unsortedIndex << std::endl;} else {std::cout << "未排序数组中未找到目标值：" << target << std::endl;}// 对不存在的元素进行查找int notExistTarget = 20;int notExistIndex = binarySearch(arr, notExistTarget, 0, n - 1);if (notExistIndex != -1) {std::cout << "数组中找到目标值：" << notExistTarget << "，位置为：" << notExistIndex << std::endl;} else {std::cout << "数组中未找到目标值：" << notExistTarget <<std::endl;}return 0;}```六、实验结果与分析1. 对已排序的数组进行查找，折半查找法成功找到了目标值，查找效率较高。
数据结构-折半查找,哈希查找
一、实验目的熟练掌握顺序查找，折半查找和哈希表等算法的程序实现。
二、实验内容1、实现折半查找的算法编写一个程序，输出在顺序表（1,2,3,4,,6,7,8,9,10）中采用折半查找方法查找关键字9的过程要求：输出查找过程中的比较对象和被查找元素的位置。
2、实现哈希表的相关运算算法编写程序实现哈希表的构造过程。
要求：建立关键字序列（16,74,60,43,54,90,46,31,29,88,77）对应的哈希表A[0...12]，哈希函数为H（k）=k%p，并采用开放定址法中的线性探测法解决冲突。
输出构造完成后的哈希表。
程序源代码及运行结果（运行结果可以截图，也可以文字描述分析）1#include<stdio.h>#include<stdlib.h>int fun(int a[],int key){int high=9;int low=0;int mid=(high+low)/2;printf("与之相比较的值为:");while(high>=low){if(key==a[mid]){printf("%-2d",a[mid]);printf("\nkey为数组中第%d个元素\n",mid+1);break;}if(key<a[mid]){ printf("%-2d",a[mid]);high=mid-1;mid=(high+low)/2;}if(key>a[mid]){ printf("%-2d",a[mid]);low=mid+1;mid=(high+low)/2;}}}int main(){int a[10]={1,2,3,4,5,6,7,8,9,10};fun(a,9);system("pause");}运行截图：2#include<stdio.h>int main(){int a[11]={16,74,60,43,54,90,46,31,29,88,77};int A[13]={0};int p=11,H;for(int i=0;i<11;i++){H=a[i]%p;while(A[H]!=0){H++;if(H==12){H=0;}}A[H]=a[i];}for(int i=0;i<13;i++){if(A[i]!=0){printf("%d ",A[i]);}}}运行截图三、小结（不少于100字）感觉好像没有真正理解哈希表，折半查找比较好理解，实现起来也比较容易，自己对代码的熟练程度还不够，课后还会多多练习，查找的方式还有很多，课后应该多看书，对每种算法都有一定的了解。
实验六 折半和二叉排序树查找实验
软件学院数据结构实验报告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、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。
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的数据元素。
数据结构查找算法实验报告
数据结构实验报告实验第四章：实验：简单查找算法一．需求与规格说明：查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找与哈希表查找四种方法。
由于自己能力有限,本想实现其她算法,但没有实现.其中顺序查找相对比较简单,折半查找参考了书上得算法，二叉排序树查找由于有之前做二叉树得经验，因此实现得较为顺利，哈希表感觉做得并不成功，感觉还就是应该可以进一步完善，应该说还有很大得改进余地。
二．设计思想:开始得时候提示输入一组数据。
并存入一维数组中，接下来调用一系列查找算法对其进行处理。
顺序查找只就是从头到尾进行遍历。
二分查找则就是先对数据进行排序，然后利用三个标志，分别指向最大，中间与最小数据，接下来根据待查找数据与中间数据得比较不断移动标志，直至找到。
二叉排序树则就是先构造,构造部分花费最多得精力,比根节点数据大得结点放入根节点得右子树，比根节点数据小得放入根节点得左子树，其实完全可以利用递归实现，这里使用得循环来实现得,感觉这里可以尝试用递归.当二叉树建好后，中序遍历序列即为由小到大得有序序列，查找次数不会超过二叉树得深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则就是利用给定得函数式建立索引,方便查找.三．设计表示:四．实现注释:其实查找排序这部分与前面得一些知识联系得比较紧密，例如顺序表得建立与实现，顺序表节点得排序,二叉树得生成与遍历，这里主要就是中序遍历.应该说有些知识点较为熟悉,但在实现得时候并不就是那么顺利。
在查找到数据得时候要想办法输出查找过程得相关信息，并统计。
这里顺序查找与折半查找均使用了数组存储得顺序表，而二叉树则就是采用了链表存储得树形结构。
为了直观起见，在用户输入了数据后,分别输出已经生成得数组与树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计.二叉排序树应该说由于有了之前二叉树得基础，并没有费太大力气,主要就是在构造二叉树得时候，要对新加入得节点数据与跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构实验五---查找的实现
实验五查找得实现一、实验内容1、建立一个线性表,对表中数据元素存放得先后次序没有任何要求.输入待查数据元素得关键字进行查找。
为了简化算法,数据元素只含一个整型关键字字段,数据元素得其余数据部分忽略不考虑.建议采用前哨得作用，以提高查找效率。
2、查找表得存储结构为有序表,输入待查数据元素得关键字利用折半查找方法进行查找.此程序中要求对整型量关键字数据得输入按从小到大排序输入。
二、源代码与执行结果1、＃inclｕｄｅ〈ｉoｓtreａm>ｕsiｎg namespace stｄ；＃defｉne MAX １０0＃deｆinｅ KｅyTｙpe iｎｔtypｅｄef stｒuct{ＫｅｙＴｙpe key ；｝DataTｙpe；typedef struｃt{ﻩDaｔaＴyｐｅ elem[ＭAX］ ;iｎｔlength ；}SeqTａble ，＊PSeｑTable ；PSeｑTable Ｉniｔ_SｅqＴable（){ﻩＰSｅqTable p ＝（ＰＳｅｑTable）malｌoc(ｓizeof（SeｑTable)) ;ﻩiｆ（p ！＝ＮULＬ）｛p->lｅｎgtｈ = 0 ；ﻩｒｅｔｕrnｐ；}ﻩelsｅ｛ﻩｃｏｕt〈<"Ouｔｏf space!”〈〈endl ；ﻩrｅtuｒn NＵＬL;ﻩ}｝int insert＿SeqTable（PSeｑTable p,KeｙType x){ｉｆ(ｐ-＞length〉= ＭＡX）ﻩ｛ﻩcｏｕt〈<”ｏverｆｌow！"<<endl ;ﻩreｔuｒn 0 ；ﻩ}ｐ—>ｅlem[ｐ—＞leｎgｔh］、key＝ x ;p-〉ｌｅｎｇtｈ+＋；reｔurｎ 1 ;｝iｎｔ SｅqSｅarch（SｅqTａble s ,KｅｙTypｅk){ﻩｉnt n ， i = ０；ﻩn = s、ｌength ；s、eleｍ［n］、ｋeｙ =ｋ ;ﻩwhilｅ（s、eｌem[i］、key ！= k）ﻩﻩi ＋+ ;ﻩif(i == n）retｕrn —1 ；elseﻩﻩrｅturn i ;}ｖoidｍain（）｛PSeｑTabｌe ｐ ;intｉ , ｎ；ﻩKeyＴype a ;p =Ｉnit_ＳｅqTaｂｌｅ（）；ﻩｃout<〈"请输入数据个数：" ;ｃin＞>n ；couｔ〈＜＂请输入数据：”＜〈endｌ ;fｏr(ｉ = 0 ; ｉ＜ n ;ｉ＋+）ﻩ{ﻩciｎ〉＞a ；ﻩinsert_SｅqTaｂle（p , a）；｝ﻩcｏut＜＜"请输入要查找得数据，输入3２76７结束：” ；cin〉〉ａ ;ﻩwｈiｌｅ（a ！= ３27６７)ﻩ｛i =SｅｑSearcｈ(*p， a) ；ｉf（i == -１）{ﻩﻩﻩcｏｕt＜＜”无此数据!请重新输入：＂<〈ｅｎｄl ；ﻩﻩcin＞＞a ；ﻩ｝ﻩﻩeｌｓeﻩﻩ｛ﻩcout＜〈"该数据得位置就是：＂〈<i+1<<enｄｌ；ﻩcouｔ〈＜＂请输入要查找得数据：" ；ﻩﻩｃiｎ〉〉ａ；ﻩ}ﻩ｝｝2、＃incｌｕde<iosｔream>usinｇ naｍespace stｄ；#defｉne MAX 100＃dｅfine KeyTyｐe ｉｎtｔyｐedef sｔruct{KeyTｙpe key ；｝ＤataTypｅ；typedeｆ stｒuｃt｛ﻩDataType ｅｌem［MAX] ；ﻩinｔ length ；}BinTａbｌe ,＊PBｉnＴabｌe ;PBinTabｌｅ Iniｔ_BiｎTablｅ（）｛ﻩPBinＴable p = (PBiｎTabｌe)mａlloｃ（sizeof(ＢinTable）) ;if(p ！= ＮULＬ)｛p->length= ０；ﻩﻩｒeturn p ；ﻩ}eｌseﻩ{ﻩｃout〈<＂Ｏｕt ｏｆ spａｃe！"〈＜endl ;rｅturｎ NUＬL ;ﻩ｝｝int iｎsｅｒt＿BinTａble（PBinTａble p ，ＫｅyTｙpe x）{ｉf（p—〉ｌｅnｇth ＞＝ MAX)｛ﻩｃoｕt<＜"ｏｖerflow!”<〈ｅnｄl ;ﻩreturn 0 ;ﻩ}ﻩp－〉ｅlｅm［p—＞lｅngtｈ］、key =x ;ｐ->ｌengtｈ ++ ；ﻩreturn １；}int ＢinSearｃh（BinTable s ，KeyTｙpe k）｛ﻩint lｏw,mid , ｈiｇｈ；ﻩloｗ = 0 ；high = s、lｅngth-1 ;ｗｈile（low ＜= hiｇh）{ﻩﻩmid＝(ｌow+higｈ）／2 ；ﻩif(s、ｅlｅm［mｉd]、kｅy== k)ﻩﻩﻩretｕrｎｍiｄ;ﻩｅlse ｉｆ（s、elem[mｉd］、ｋｅy ＞ｋ）ﻩﻩhiｇh＝ mｉｄ－ 1 ;ﻩﻩｅlｓeﻩlow = mid +1 ；ﻩ｝ﻩrｅturn —1；}ｖoiｄ main（)｛PBinTablｅ p ；ﻩintｉ ,n ；ﻩKeyType ａ;p ＝Iｎit＿BinＴable（）;ｃｏuｔ<<”请输入数据个数：”;ｃｉn〉＞n；ﻩｃout<〈"请按从小到大得顺序输入数据：”〈<ｅndｌ；fｏr(i = 0 ；ｉ〈 n; i ++）ﻩ｛ｃin>〉a;ﻩinsert_BinTable（ｐ，a）;｝ﻩcout＜<＂请输入要查找得数据,输入32767结束：” ;ﻩcin〉＞ａ ;whilｅ（a！= 3２767){ﻩi =BｉｎSeaｒｃh（*p , ａ）；iｆ（ｉ =＝-1）ﻩ{ﻩﻩcｏut〈〈＂无此数据！请重新输入:＂〈〈ｅndl ;ｃiｎ>>a;ﻩ}ﻩelｓe{ﻩcout＜<"该数据得位置就是：”〈<i+1〈＜ｅndl ；ﻩﻩﻩｃｏut＜〈”请输入要查找得数据:" ；cin＞〉a ;}ﻩ}｝。
数据结构实验报告折半查找
数据结构实验报告折半查找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表示查找失败。
数据结构实验---折半查找实验报告
深圳大学实验报告课程名称：数据结构实验项目名称：查找排序之折半查找学院：信息工程学院专业：电子信息工程指导教师：报告人：学号：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. 掌握折半查找算法的实现方法。
3. 分析折半查找算法的时间复杂度和空间复杂度。
4. 比较折半查找算法与顺序查找算法的性能差异。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验原理折半查找算法，又称二分查找算法，是一种在有序数组中查找特定元素的算法。
其基本原理是将待查找的元素与数组的中间元素进行比较，若相等，则查找成功；若小于中间元素，则在数组的左半部分继续查找；若大于中间元素，则在数组的右半部分继续查找。
重复此过程，直到找到目标元素或查找失败。
折半查找算法的时间复杂度为O(log2n)，空间复杂度为O(1)。
四、实验步骤1. 创建一个有序数组。
2. 实现折半查找算法。
3. 比较折半查找算法与顺序查找算法的性能差异。
五、实验代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1def sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1# 创建有序数组arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]# 查找目标元素target = 7# 折半查找index_binary = binary_search(arr, target)# 顺序查找index_sequential = sequential_search(arr, target) # 比较性能import timestart_time = time.time()binary_search(arr, target)end_time = time.time()binary_time = end_time - start_timestart_time = time.time()sequential_search(arr, target)end_time = time.time()sequential_time = end_time - start_timeprint(f"折半查找结果：索引 {index_binary}")print(f"顺序查找结果：索引 {index_sequential}")print(f"折半查找耗时：{binary_time} 秒")print(f"顺序查找耗时：{sequential_time} 秒")```六、实验结果与分析1. 折半查找结果：索引 32. 顺序查找结果：索引 33. 折半查找耗时：0.0002 秒4. 顺序查找耗时：0.0005 秒实验结果表明，折半查找算法在查找相同目标元素时，耗时明显低于顺序查找算法。
折半查找的实验报告
折半查找的实验报告折半查找的实验报告引言：在计算机科学领域，查找是一项基本操作。
而折半查找，也被称为二分查找，是一种高效的查找算法。
本实验旨在通过实际操作和数据分析，探究折半查找算法的原理和性能。
实验设计：本次实验使用C++语言来实现折半查找算法，并通过编写测试程序来验证算法的正确性和性能。
我们使用了一个已排序的整数数组，其中包含了10000个元素。
实验过程中，我们将记录算法的查找次数和运行时间，并与线性查找算法进行对比。
实验步骤：1. 首先，我们定义一个包含10000个已排序整数的数组，并选择一个待查找的目标值。
2. 接下来，我们实现折半查找算法。
该算法的基本思想是将待查找的目标值与数组的中间元素进行比较，如果相等则返回找到的位置，如果目标值小于中间元素，则在左半部分继续查找，否则在右半部分继续查找。
重复这个过程，直到找到目标值或者确定目标值不存在。
3. 我们编写测试程序，分别使用折半查找算法和线性查找算法来查找目标值，并记录查找次数和运行时间。
4. 重复多次实验，以获得更准确的结果。
同时，我们还可以改变目标值的位置，观察算法的性能变化。
实验结果：经过多次实验，我们得到了如下结果：- 折半查找算法的平均查找次数为log2(10000)≈13次，而线性查找算法的平均查找次数为10000次。
- 折半查找算法的平均运行时间为0.0001秒，而线性查找算法的平均运行时间为0.01秒。
- 当目标值位于数组的中间位置时，折半查找算法的性能最佳；而当目标值位于数组的两端时，折半查找算法的性能最差。
讨论与分析：通过对实验结果的分析，我们可以得出以下结论：1. 折半查找算法的时间复杂度为O(log n)，而线性查找算法的时间复杂度为O(n)。
因此，折半查找算法在大规模数据中的查找效率远高于线性查找算法。
2. 折半查找算法适用于已排序的数据集，而线性查找算法对数据集的有序性没有要求。
因此，在已排序的数据集中使用折半查找算法可以提高查找效率。
数据结构折半排序查找
折半查询一、实验目的1，掌握排序算法及基本思想及实现的技术；能够根据实际问题特点的要求选择合理的排序方法，理解排序在数据处理中的重要性；2.学会比较各种排序方法的稳定性分析以及在最好、最坏和平均情况的时间性能分析。
3.掌握顺序查找和折半查找两种查找的算法及实现技术；了解它们各自的优缺点。
4.熟悉各种查找方法的适用范围和条件；掌握顺序查找、折半查找的基本思想及效率分析。
二、实验环境1.硬件：每个学生需配备计算机一台。
操作系统：DOS或Windows2.软件：DOS或Windows操作系统+Turbo C;三、实验要求1.本次实验较为简单，每个同学独立按时完成，通过实验掌握记录的概念，为以后数据库技术打好基础。
2.如果输入数据较为繁琐，可减低每个班的人数。
3.输入输出数据要有提示，方便用户操作。
四、实验内容1.现在某个学院有20名同学分属于2个班级（Class1和Class2，每个班有10名同学，每个同学记录包括：班级、学号、姓名、性别、电话号码等信息）。
2.以学号为主关键字，以班级为次关键字，建立一个顺序表，表中的每个数据元素是一个记录，其中的某个域用来存储关键字的值，按关键字的值进行顺序查找。
为分析排序方法的稳定性，关键字可用次关键字。
#include"stdio.h"#include"malloc.h"#include"string.h"typedef struct{int cla;int num;char name[7];char sex;long phnum;}stu_hc;typedef struct{stu_hc *elem;int length;int sum;}sqlist_hc;sqlist_hc *initlist_hc(){sqlist_hc *l;int n;l=(sqlist_hc*)malloc(sizeof(sqlist_hc));if(!l)printf("出错!\n");printf("输入学生人数:");scanf("%d",&n);l->length=0;l->sum=n;l->elem=(stu_hc*)malloc(n*sizeof(stu_hc));if(!l->elem)printf("出错!\n");return(l);}int place_hc(sqlist_hc *l,int c,int num){int low,high,mid,j=-1,i;low=0;high=l->length-1;while(low<=high){mid=(low+high)/2;if(l->elem[mid].num>num)high=mid-1;else{j=mid;low=mid+1;}}i=j;for(j=mid;j>=i;j--){if(j==-1||num>l->elem[j].num)break;else if(num==l->elem[j].num&&c>l->elem[j].cla)break;} return(++j);}void move_hc(sqlist_hc *l,int j){int i;for(i=l->length-1;i>=j;i--){l->elem[i+1].cla=l->elem[i].cla;strcpy(l->elem[i+1].name,l->elem[i].name);l->elem[i+1].num=l->elem[i].num;l->elem[i+1].sex=l->elem[i].sex;l->elem[i+1].phnum=l->elem[i].phnum;}}void createlist_hc(sqlist_hc *l){int i,j,c,num;char nam[7],s;long p;printf("输入学生信息(class name num sex phonenum):\n"); for(i=0;i<l->sum;i++){flushall();scanf("%d %s %d %c %ld",&c,nam,&num,&s,&p);j=!(l->length)?0:place_hc(l,c,num);move_hc(l,j);l->elem[j].cla=c;strcpy(l->elem[j].name,nam);l->elem[j].num=num;l->elem[j].sex=s;l->elem[j].phnum=p;l->length++;}}void seekstu_hc(sqlist_hc *l){int low,high,mid,num,c;printf("输入查找人的学号和班级号:");scanf("%d %d",&num,&c);while(num!=-1||c!=-1){low=0;high=l->length-1;while(low<=high){mid=(low+high)/2;if(l->elem[mid].num<num)low=mid+1;else if(l->elem[mid].num>num)high=mid-1;else{if(l->elem[mid].cla<c)mid++;else if(l->elem[mid].cla>c)mid--;break;}}printf("%d,%s,%d,%c,%ld\n",l->elem[mid].cla,l->elem[mid].name,l->elem[mid].num,l->elem[mid].sex,l->elem[ mid].phnum);printf("输入查找人的学号和班级号:");scanf("%d %d",&num,&c);}}void printlist_hc(sqlist_hc*l){int i,j=0;printf("当前表中信息如下:class/name/num/sex/phonenum\n");for(i=0;i<l->sum;i++){printf("%d/%s/%d/%c/%ld",l->elem[i].cla,l->elem[i].name,l->elem[i].num,l->elem[i].sex,l->elem[i].phnum);if(++j==3){j=0;printf("\n");}}printf("\n");}main(){sqlist_hc *l;l=initlist_hc();createlist_hc(l);printlist_hc(l);seekstu_hc(l);printf("作者:黄晨");}。
顺序查找与折半查找实验报告
顺序查找与折半查找实验报告姓名：许严班级：计122 学号：12130230501.问题描述实现顺序查找与折半查找的程序设计，并比较两种查找方法的性能。
2.基本要求（1）设计查找表的存储结构。
（2）设计查找算法，对同一组实验数据实现查找。
（3）输入：查找表的数据个数和数据由键盘输入，数据元素类型为整型，以菜单方式选择顺序查找或折半查找中的一种，并由键盘输入想要查找的数据。
（4）输出：若查找成功输出其位置和查找次数，若查找失败输出信息和查找次数。
3.实现提示（1）存储设计由于要对一组实验数据实现顺序查找与折半查找，只能采用顺序表存放查找表数据，存储结构定义与教材一致。
设关键字类型为整型，利用前面实验建立的线性表类，生成一个线性表对象，线性表中的数据个数、数据以及待查找的数据由键盘输入。
（2）算法设计由于折半查找法要求数据是有序的，可设立一个创建有序顺序表的函数Sort(int*fp,int length)；设立一个顺序查找函数SequenSearch(int*fp,int length)实现顺序查找；设立一个折半查找函数实现折半查找；编写一个主函数main(),在主函数中设计一个简单的菜单，根据用户的选择分别调用顺序查找和折半查找算法。
4.程序设计(1) using namespace std;struct Node{int key;};class SSearch{private:Node *ST;int len;public:SSearch();~SSearch();void Create(int n);void Display();void Sort();void Sort_n(int arr[]);void SequenceSearch(int key);void Search(int key);};SSearch::SSearch(){ST=0;len=0;}SSearch::~SSearch(){if(ST) delete[]ST;len=0;}void SSearch::Create(int n){len=n;ST=new Node[len];cout<<"请输入"<<n<<"个数据元素：\n";int i=0;while(i<len){cin>>ST[i].key;i++;}cout<<"静态表创建成功！：）\n";}void SSearch::Display(){cout<<"表中数据元素依次为：\n";for(int i=0;i<len;i++)cout<<ST[i].key<<'\t';cout<<endl;}voidSSearch::Sort() //冒泡排序{int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;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;y=0;}}if(y) return;}}void SSearch::Sort_n(int arr[]){int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;j++){if(arr[j]>arr[j+1]){t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;y=0;}}if(y) return;}}void SSearch::SequenceSearch(int key){ST[0].key=key;int count=1,i=len-1; //计数边梁count为1的原因是下面的for语句先判定在count++ for(;ST[i].key!=key;i--,count++);if(i){cout<<"查找成功！\n在顺序表的第"<<i<<"个位置（从0开始），一共比较了"<<count<<"次。
数据结构实验报告-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树：二叉查找树是一个满足以下条件的树：任意一个结点的关键字，都大于(小于)其左(右)子树中任意结点的关键字，因此各结点的关键字互不相同按中序遍历二叉查找树所得的中序序列是一个递增的有序序列，因此，二叉查找树可以把无序序列变为有序序列。
同一个数据集合，可按关键字表示成不同的二叉查找树，即同一数据集合的二叉查找树不唯一；但中序序列相同。
武汉纺织大学《数据结构》实验报告4
武汉纺织大学《数据结构》实验报告班级：级管工类专业班姓名：序号： 1实验时间： 2014 年 5 月 30 日指导教师：实验四：查找基本操作与应用一、实验目的：1、掌握顺序查找、折半查找、哈希查找的基本方法和操作过程2、掌握查找效率的分析方法二、实验内容：1、编写程序，实现顺序查找操作，可参考书本P260示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（对元素存放的先后顺序没有要求），并按照存储顺序输出所有元素；②、输入带查找关键字，在顺序表中进行顺序查找；③、输出查找结果。
2、编写程序，实现有序表折半查找操作，可参考书本P263示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（要求所有元素按照递增顺序排列），并按照存储顺序输出所有元素；②、输入带查找关键字，在有序表中进行折半查找；③、输出查找结果。
3、编写程序，实现哈希表查找操作。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长12），依次输入10个数据元素，并按照存储顺序输出所有元素；②、输入带查找关键字，在哈希表中进行查找；③、输出查找结果。
已知：哈希函数为H(key)=key MOD 11，采用开放地址法、线性探测再散列解决冲突，输入元素为{ 55,19,31,23,68,20,27,9,10,79}。
三、操作步骤：Test1代码：T1.Javapackage First;import java.util.Scanner;public class T1 {public static void main(String[] args) {int i;int n;Scanner sc=new Scanner(System.in);SeqList<Integer> sl=new SeqList<Integer>(10);sl.insert(0, 3);sl.insert(6, 1);sl.insert(6, 0);sl.insert(8, 6);sl.insert(7, 2);sl.insert(2,9);sl.insert(4, 1);sl.insert(5, 4);sl.insert(6,8);sl.insert(1, 7);System.out.print("顺序表中各元素:");System.out.println(sl.toString());System.out.println("<查找元素>");System.out.print("输入元素:");i=sc.nextInt();n=sl.indexOf(i);if(n!=-1)System.out.println("元素" +i+"位于第"+n+"位");}}LList.javapackage First;public interface LList<T> {boolean isEmpty();int length();T get(int i);void set(int i, T x);void insert(int i, T x);T remove(int i);void removeAll();}SeqList .javapackage First;public class SeqList<T> implements LList<T> { private Object[] element;private int len;public SeqList(int size) {this.element = new Object[size];this.len = 0;}public SeqList() {this(64);}public boolean isEmpty() {return this.len == 0;}public int length() {return this.len;}public T get(int i) {if (i >= 0 && i < this.len)return (T) this.element[i];return null;}public void set(int i, T x) {if (x == null)return;if (i >= 0 && i < this.len)this.element[i] = x;elsethrow new IndexOutOfBoundsException(i + "");}public String toString() {String str = "(";if (this.len > 0)str += this.element[0].toString();for (int i = 1; i < this.len; i++)str += "," + this.element[i].toString();return str + ")";}public void insert(int i, T x){if(x==null)return;if(this.len==element.length){Object[]temp = this.element;this.element = new Object[temp.length*2];for(int j=0;j<temp.length;j++)this.element[j]=temp[j];}if(i<0)i=0;if(i>this.len)i=this.len;for(int j=this.len-1;j>=i;j--)this.element[j+1]=this.element[j];this.element[i]=x;this.len++;}public void append(T x){ insert(this.len,x); } public T remove(int i){if(this.len==0||i<0||i>=this.len)return null;T old = (T)this.element[i];for(int j=i;j<this.len-1;j++)this.element[j]=this.element[j+1];this.element[this.len-1]=null;this.len--;return old;}public void removeAll(){ this.len=0; } public int indexOf(T key){if(key!=null)for(int i=0;i<this.len;i++)if(this.element[i].equals(key))return i;return -1;}public T search(T key){int find=this.indexOf(key);return find==-1?null:(T)this.element[find]; }public boolean contain(T key){return this.indexOf(key)>=0;}}运行结果：Test2代码：T2.javapackage Second;public class T2 {public static void main(String[] args) {int a[]={5,11,23,15,17,38,90,121,132,164}; int search=38;int lower=0;int temp=a.length-1 ;int index=-1;while(lower<=temp){index = (lower+temp)/2;int currentValue=a[index];if(currentValue==search){break;}else if(currentValue<search){lower=index+1;}else{temp = index-1;}}for(int i = 0;i < 10; i++){System.out.print(a[i]);System.out.println(" ");}if(lower<=temp){System.out.println("查找元数"+search);System.out.println("位于数组中第"+(index+1)+"位");}else{System.out.println("里面没有这个元素"); }}}运行结果：Test3代码：T3.javapackage Three;import java.util.Scanner;public class T3 {static HashTable T=null;public static void createHashtable() throws Exception { T=new HashTable(20);Scanner sc=new Scanner(System.in);System.out.print("请输入待查找的关键字的个数:");int n=sc.nextInt();System.out.print("请输入查找表中的关键字序列:");for (int i = 0; i < n; i++) {T.hashInsert(sc.nextInt());}}public static void main(String[]args)throws Exception{System.out.println("<创建哈希表>");createHashtable();System.out.println("创建的哈希表为:");T.Hashdisplay();System.out.print("输入待查找的关键字:");Scanner sc=new Scanner(System.in);int key=sc.nextInt();RecordNode p=T.hashSearch(key);if ((p.getKey()).compareTo(key)==0)System.out.println(" 查找成功!");elseSystem.out.println(" 查找失败!");}}KeyType.javapackage Three;public class KeyType implements Comparable<KeyType> {private int key;public KeyType() {}public KeyType(int key) {this.key = key;}public int getKey() {return key;}public void setKey(int key) {this.key = key;}public String toString() {return key + "";}public int compareTo(KeyType another) {int thisVal = this.key;int anotherVal = another.key;return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));}}class HashTable {private RecordNode[] table;public HashTable(int size) {this.table = new RecordNode[size];for (int i = 0; i < table.length; i++) {table[i] = new RecordNode(0);}}public int hash(int key) {return key % 11;}public RecordNode hashSearch(int key) {int i = hash(key);int j = 0;while ((table[i].getKey().compareTo(0) != 0)&& (table[i].getKey().compareTo(key) != 0)&& (j < table.length)) {j++;i = (i + j) % 11;}if (j >= table.length) {System.out.println("哈希表已满");return null;} elsereturn table[i];}public void hashInsert(int key) {RecordNode p = hashSearch(key);if (p.getKey().compareTo(0) == 0)p.setKey(key);elseSystem.out.println(" 此关键字记录已存在或哈希表已满");}void Hashdisplay() {for (int i = 0; i < table.length; i++)System.out.print(table[i].getKey().toString() + " ");System.out.println();}}RecordNode.javapackage Three;public class RecordNode {private Comparable key;private Object element;public Object getElement() {return element;}public void setElement(Object element) {this.element = element;}public Comparable getKey() {return key;}public void setKey(Comparable key) {this.key = key;}public RecordNode() {this.key = null;}public RecordNode(Comparable key) {this.key = key;}}运行结果：四、实验收获和建议这次实验我掌握了顺序查找、折半查找、哈希查找的基本方法和操作过程，掌握查找效率的分析方法，对查找方法有了更进一步的认识。
分治算法折半查找实验总结
分治算法折半查找实验总结导言：分治算法是一种常用的问题解决方法，其核心思想是将问题划分为更小的子问题进行解决，最后将子问题的解合并得到原问题的解。
折半查找是一种高效的查找算法，适用于有序数组。
本文将结合实验结果对分治算法折半查找进行总结和分析。
一、算法原理折半查找（Binary Search）是一种基于分治思想的查找算法。
假设有一个有序数组arr，要查找的元素为target。
首先，取数组的中间元素mid。
若target等于mid，则查找成功；若target小于mid，则在数组的左半部分继续查找；若target大于mid，则在数组的右半部分继续查找。
通过不断地折半查找，最终可以确定是否存在目标元素，并找到其位置。
二、实验过程为了验证折半查找算法的效果，我们在实验中使用了一个有序数组arr，并设定了不同的查找目标。
实验步骤如下：1. 初始化一个有序数组arr；2. 输入要查找的目标元素target；3. 调用折半查找函数，传入数组arr和目标元素target；4. 根据查找结果输出查找成功或失败的信息。
三、实验结果我们进行了多次实验，分别在不同规模的有序数组中查找不同的目标元素。
以下是实验结果的总结：1. 当目标元素存在于数组中时，折半查找能够准确找到目标元素的位置，并输出查找成功的信息。
这证明了折半查找的正确性和有效性。
2. 当目标元素不存在于数组中时，折半查找会返回查找失败的信息。
这表明算法能够正确判断目标元素的存在与否。
四、实验分析通过实验结果的总结，我们可以得出以下分析：1. 折半查找算法的时间复杂度为O(logn)，其中n为数组的长度。
相比于线性查找算法的时间复杂度O(n)，折半查找具有更高的效率。
2. 折半查找算法要求数组必须是有序的，否则无法正常运行。
因此，在使用折半查找算法之前，需要确保数组的有序性。
3. 折半查找算法对内存空间的要求较低，只需要存储数组和几个变量即可。
这使得折半查找算法适用于大规模数据的查找。
数据结构查找算法实验报告
数据结构实验报告实验第四章:实验: 简单查找算法一．需求与规格说明:查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找与哈希表查找四种方法。
由于自己能力有限,本想实现其她算法,但没有实现。
其中顺序查找相对比较简单,折半查找参考了书上的算法,二叉排序树查找由于有之前做二叉树的经验,因此实现的较为顺利,哈希表感觉做的并不成功,感觉还就是应该可以进一步完善,应该说还有很大的改进余地。
二．设计思想:开始的时候提示输入一组数据。
并存入一维数组中,接下来调用一系列查找算法对其进行处理。
顺序查找只就是从头到尾进行遍历。
二分查找则就是先对数据进行排序,然后利用三个标志,分别指向最大,中间与最小数据,接下来根据待查找数据与中间数据的比较不断移动标志,直至找到。
二叉排序树则就是先构造,构造部分花费最多的精力,比根节点数据大的结点放入根节点的右子树,比根节点数据小的放入根节点的左子树,其实完全可以利用递归实现,这里使用的循环来实现的,感觉这里可以尝试用递归。
当二叉树建好后,中序遍历序列即为由小到大的有序序列,查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则就是利用给定的函数式建立索引,方便查找。
三．设计表示:四．实现注释:其实查找排序这部分与前面的一些知识联系的比较紧密,例如顺序表的建立与实现,顺序表节点的排序,二叉树的生成与遍历,这里主要就是中序遍历。
应该说有些知识点较为熟悉,但在实现的时候并不就是那么顺利。
在查找到数据的时候要想办法输出查找过程的相关信息,并统计。
这里顺序查找与折半查找均使用了数组存储的顺序表,而二叉树则就是采用了链表存储的树形结构。
为了直观起见,在用户输入了数据后,分别输出已经生成的数组与树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础,并没有费太大力气,主要就是在构造二叉树的时候,要对新加入的节点数据与跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构折半查找实验--深圳大学郭治民
实验十三：折半查找一：代码：#include <iostream>using namespace std;class BinSearch{public:void CreateSequence(int*, int);int BinSearchKey(int);int BinSuccess;int BinPos;int BinCount;private:int BinList[32];int BinListLen;};void BinSearch::CreateSequence(int *r, int n) {int i, j, temp;BinListLen = n;for (i=1; i<n; i++){if(r[i] < r[i-1]){temp = r[i];for (j = i-1; j >= 0; j-=1)if (temp < r[j])r[j+1] = r[j];elsebreak;r[j+1] = temp;}}for (i=1; i <= n; i++)BinList[i] = r[i-1];}int BinSearch::BinSearchKey(int Key){int Low , High, mid;Low = 1;High = BinListLen;BinCount=0;while (Low <= High){mid = (Low + High)/2;if(BinList[mid]==Key){BinSuccess=1;BinCount++;BinPos=mid;break;}else{BinSuccess=0;BinCount++;BinPos=0;}if(Key>BinList[mid])Low = mid +1;elseHigh = mid -1;}return 0;}int main (int argc, char* argv[]) {int r[32];int i, j, Key;int TestNum, SampleNum;BinSearch *BS = new BinSearch;cin >> TestNum;for (i=0; i < TestNum; i++){cin >> SampleNum;for (j=0; j < SampleNum; j++) cin >> r[j];BS->CreateSequence(r, SampleNum);cin >> Key;BS->BinSearchKey(Key);cout << BS->BinSuccess << " " <<BS->BinPos<< " " << BS->BinCount << endl;}return 0;}二、结果截图：学号：2011150117郭治民。
折半查找 插入排序 高斯消去法实验报告
算法设计与分析基础应用数学学院二零一六年六月实验三折半查找插入排序和高斯消去法一、实验性质由算法伪代码设计java代码二、实验学时3学时三、实验目的1、理解折半查找的算法过程，并设计相应的java程序。
2、理解插入排序的算法过程，并设计相应的java程序。
3、理解高斯消去法的算法过程，并设计相应的java程序。
四、实验要求实验一、折半查找：由用户在输入要查询的数字，经运行程序，实现非递归的折半查找，并输出用户所查数字所在位置。
实验二、插入排序：由用户输入一串数字（7个），按照提示要求输入。
经插入排序，将用户输入数字进行排序输出，并可以给出出入排序过程。
实验三、高斯消去法：给定一个方程组的系数矩阵及一个解向量，通过高斯消去法，将矩阵变为上三角矩阵，从而快速求出矩阵所在方程的解。
五、实验内容实验一、折半查找：1、实现非递归的折半查找。
2、输入：一个升序数组a[]，和一个需要查找的数组k。
3、输出：一个数组k元素的下标，如果没有查找到，则提示用户。
实验二、插入排序：1、用插入排序对给定的数字进行排序。
2、输入：n个可以排序元素构成的数组a[]；3、输出：非降序的依次输出排列数组a[]。
实验三、高斯消去法：1、对一个方程组的系数矩阵a[][]，应用高斯消元法。
2、用该方程组右边的值构成的向量b来扩展矩阵。
3、输出：一个可以代替a[][]的上三角等阶矩阵图，相应的右边的值位于最后一列。
实验报告实验一折半查找：Java代码：package cn;import java.util.Scanner;public class ZheBan {public static void main(String[] args){int []a={3,14,27,31,39,42,55,70,74,81,85,93,98};Scanner can = new Scanner(System.in);System.out.println("请输入要查找的数字：");int k=can.nextInt();int l=0,r=a.length;while(l<=r){int m;m=(l+r)/2;if(k==a[m]){System.out.print("您查找的数字在第"+(m+1)+"位");break;}else if(k<a[m]){r=m-1;}else {l=m+1;}}if(l>r){System.out.print("未找到您要查找的数字。
折半查找数据结构实验报告
数据结构实验报告三题目：试编写利用折半查找确定记录所在块的分块查找算法。
提示：1)读入各记录建立主表；2)按L个记录/块建立索引表；3)对给定关键字k进行查找；测试实例: 设主表关键字序列: {12 22 13 8 28 33 38 42 87 76 50 63 99 101 97 96}, L=4 , 依次查找K=13, K=86, K=88算法思路题意要求对输入的关键字序列先进行分块, 得到分块序列。
由于序列不一定有序, 故对分块序列进行折半查找, 找到关键字所在的块, 然后对关键字所在的块进行顺序查找, 从而找到关键字的位置。
故需要折半查找和顺序查找两个函数, 考虑用C++中的类函数实现。
因为序列一般是用数组进行存储的, 这样可以调用不同类型的数组, 程序的可适用性更大一些。
折半查找函数:int s,d,ss,dd;//声明一些全局变量, 方便函数与主函数之间的变量调用。
template <class T>int BinSearch(T A[],int low,int high,T key)//递归实现折半查找{int mid;// 初始化中间值的位置T midvalue;// 初始化中间值if (low>high){s=A[high];d=A[low];ss=high;dd=low;return -1;}// 如果low的值大于high的值, 输出-1, 并且将此时的low与high的值存储。
else{mid=(low+high)/2;// 中间位置为低位与高位和的一半取整。
midvalue=A[mid];if (midvalue==key)return mid;else if (midvalue < key) //如果关键字的值大于中间值return BinSearch(A,mid+1,high,key);// 递归调用函数, 搜索下半部分elsereturn BinSearch(A,low,mid-1,key);// 否则递归调用哦个函数, 搜索上半部分}}以上为通用的折半查找的函数代码, 这里引入了几个全局变量, 主要是方便在搜索关键字在哪一个分块中时, 作为判断条件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
深圳大学实验报告
课程名称：数据结构
实验项目名称：查找排序之折半查找
学院：信息工程学院
专业：电子信息工程
指导教师：
报告人：学号：2009100000 班级：电子1班实验时间：2011年12月2日
实验报告提交时间：2011年12月13日
教务处制
printf("\n");
return 0;
}
四、实验结论：
实结果图：
情况一、能够在待查数组中查找到待查元素
情况二、不能够在待查数组中查找到待查元素
数据分析
基于上面程序运行图可以很明显得知整个算法的实现过程，针对第一个图：
1、首先建立一个数组存放待查元素
2、针对定值key进行折半查找，第一个图可以得到key=11
3、mid=（low+high）/2 =（0+5）/2 =2.得到的是ST[2]=33,查找了一次
4、判断ST[2]=33大于key=11，即执行high=mid-1=1
5、mid=（low+high）/2 =（0+1）/2 =0.得到的是ST[0]=11=key，查找成功，查找了两次。
THANKS !!!
致力为企业和个人提供合同协议，策划案计划书，学习课件等等
打造全网一站式需求
欢迎您的下载，资料仅供参考
-可编辑修改-。