数据结构算法实现及解析c
① 数据结构（C语言版） 中一题目的算法
/***
*
*题目：已知
线性表
中的元素以值递增有序排列，并以
单链表
做存储结构。试写一高效的算法，
*
删除表中所有值大于
mink
且小于
maxk
的元素（若表中存在这样的元素）,同时释放
*
被删除节点空间，并分析你的算法的
时间复杂度
（注意：mink
和
maxk
是给定的两个
*
参变量，它们的值可以和表中的元素相同，也可以不同）
*
****/
#include
#include
#include
"DynaLinkList.h"
void
DelMminMax(LinkList
*L,
int
min,
int
max)
{
LinkList
p
=
(*L)->next,
q
=
(*L),
r;
while
(p
&&
p->data
<=
min)
{
q
=
p;
p
=
p->next;
}
while
(
p
&&
p->data
<
max)
{
r
=
p;
p
=
p->next;
q->next
=
p;
free(r);
}
}
//算法的时间复杂度为O(n)
int
main()
{
LinkList
L;
ElemType
e,
min,
max;
InitList(&L);
printf("输入8个元素建立线性表L(元素递增有序):\n");
for
(int
i=1;
i<=8;
i++)
{
scanf("%d",
&e);
ListInsert(&L,
i,
e);
}
printf("表L是：\n");
ListTraverse(L,
visit);
printf("请输入待删除的元素的区间是(min,max):\n");
scanf("%d%d",
&min,
&max);
DelMminMax(&L,min,max);
printf("删除(%d,%d)之间的元素后表L是：\n",min,max);
ListTraverse(L,
visit);
return
0;
}
② 数据结构与算法分析：C语言描述的内容简介
《数据结构与算法分析:C语言描述(原书第2版)》内容简介：书中详细介绍了当前流行的论题和新的变化，讨论了算法设计技巧，并在研究算法的性能、效率以及对运行时间分析的基础上考查了一些高级数据结构，从历史的角度和近年的进展对数据结构的活跃领域进行了简要的概括。由于《数据结构与算法分析:C语言描述(原书第2版)》选材新颖，方法实用，题例丰富，取舍得当。《数据结构与算法分析:C语言描述(原书第2版)》的目的是培养学生良好的程序设计技巧和熟练的算法分析能力，使得他们能够开发出高效率的程序。从服务于实践又锻炼学生实际能力出发，书中提供了大部算法的C程序和伪码例程，但并不是全部。一些程序可从互联网上获得。
《数据结构与算法分析:C语言描述(原书第2版)》是《Data Structures and Algorithm Analysis in C》一书第2版的简体中译本。原书曾被评为20世纪顶尖的30部计算机着作之一，作者Mark Allen Weiss在数据结构和算法分析方面卓有建树，他的数据结构和算法分析的着作尤其畅销，并受到广泛好评．已被世界500余所大学用作教材。
在《数据结构与算法分析:C语言描述(原书第2版)》中，作者更加精炼并强化了他对算法和数据结构方面创新的处理方法。通过C程序的实现，着重阐述了抽象数据类型的概念，并对算法的效率、性能和运行时间进行了分析。
全书特点如下：
●专用一章来讨论算法设计技巧，包括贪婪算法、分治算法、动态规划、随机化算法以及回溯算法
●介绍了当前流行的论题和新的数据结构，如斐波那契堆、斜堆、二项队列、跳跃表和伸展树
●安排一章专门讨论摊还分析，考查书中介绍的一些高级数据结构
●新开辟一章讨论高级数据结构以及它们的实现，其中包括红黑树、自顶向下伸展树。treap树、k-d树、配对堆以及其他相关内容
●合并了堆排序平均情况分析的一些新结果
《数据结构与算法分析:C语言描述(原书第2版)》是国外数据结构与算法分析方面的标准教材，介绍了数据结构(大量数据的组织方法)以及算法分析(算法运行时间的估算)。《数据结构与算法分析:C语言描述(原书第2版)》的编写目标是同时讲授好的程序设计和算法分析技巧，使读者可以开发出具有最高效率的程序。 《数据结构与算法分析:C语言描述(原书第2版)》可作为高级数据结构课程或研究生一年级算法分析课程的教材，使用《数据结构与算法分析:C语言描述(原书第2版)》需具有一些中级程序设计知识，还需要离散数学的一些背景知识。
③ 数据结构如何通过C语言来实现，请举例说明，尽可能详细
数据的结构无非就是表：线性表、链表，栈，队列，串，数组，树、二叉树，图，这几种。
常用的使用指针，或数组建立数据结构，然后对其进行插入、删除、查找、排序等操作。
以下是C语言实现的循环队列：
#include<stdio.h>
#include<stdlib.h>
#define MAX_QSIZE 5
struct SqQueue
{ QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针，若队列不空，指向队列头元素
int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置
};
// bo3-4.cpp 循环队列(存储结构由c3-3.h定义)的基本操作(9个)
void InitQueue(SqQueue &Q)
{ // 构造一个空队列Q。在教科书第64页
Q.base=(QElemType*)malloc(MAX_QSIZE*sizeof(QElemType));
if(!Q.base) // 存储分配失败
exit(OVERFLOW);
Q.front=Q.rear=0;
}
void DestroyQueue(SqQueue &Q)
{ // 销毁队列Q，Q不再存在
if(Q.base) // 队列Q存在
free(Q.base); // 释放Q.base所指的存储空间
Q.base=NULL; // Q.base不指向任何存储单元
Q.front=Q.rear=0;
}
void ClearQueue(SqQueue &Q)
{ // 将队列Q清为空队列
Q.front=Q.rear=0;
}
int QueueEmpty(SqQueue Q)
{ // 若队列Q为空队列，则返回TRUE；否则返回FALSE
if(Q.front==Q.rear) // 队列空的标志
return TRUE;
else
return FALSE;
}
int GetHead(SqQueue Q,QElemType &e)
{ // 若队列Q不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
if(Q.front==Q.rear) // 队列空
return ERROR;
e=Q.base[Q.front]; // 将队头元素的值赋给e
return OK;
}
int EnQueue(SqQueue &Q,QElemType e)
{ // 插入元素e为队列Q的新的队尾元素。在教科书第65页
if((Q.rear+1)%MAX_QSIZE==Q.front) // 队列满
return ERROR;
Q.base[Q.rear]=e; // 将e插在队尾
Q.rear=(Q.rear+1)%MAX_QSIZE; // 队尾指针+1后对MAX_QSIZE取余
return OK;
}
int QueueLength(SqQueue Q)
{ // 返回队列Q的元素个数，即队列的长度。在教科书第64页
return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;
}
int DeQueue(SqQueue &Q,QElemType &e) // 在教科书第65页
{ // 若队列Q不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
if(Q.front==Q.rear) // 队列空
return ERROR;
e=Q.base[Q.front]; // 将队头元素的值赋给e
Q.front=(Q.front+1)%MAX_QSIZE; // 移动队头指针
return OK;
}
void QueueTraverse(SqQueue Q,void(*visit)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数visit()
int i=Q.front; // i最初指向队头元素
while(i!=Q.rear) // i指向队列Q中的元素
{ visit(Q.base[i]); // 对i所指元素调用函数visit()
i=(i+1)%MAX_QSIZE; // i指向下一个元素
}
printf("\n");
}
void main()
{
int j;
int i=0,m;
int d;
SqQueue Q;
InitQueue(Q); // 初始化队列Q，失败则退出
printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("请输入整型队列元素(不超过%d个)，-1为提前结束符：",MAX_QSIZE-1);
do
{ scanf("%d",&d); // 由键盘输入整型队列元素
if(d==-1) // 输入的是提前结束符
break; // 退出输入数据循环
i++; // 计数器+1
EnQueue(Q,d); // 入队输入的元素
}while(i<MAX_QSIZE-1); // 队列元素的个数不超过允许的范围
printf("队列长度为%d，",QueueLength(Q));
printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("连续%d次由队头删除元素，队尾插入元素：\n",MAX_QSIZE);
for(m=1;m<=MAX_QSIZE;m++)
{ DeQueue(Q,d); // 删除队头元素，其值赋给d
printf("删除的元素是%d，请输入待插入的元素：",d);
scanf("%d",&d); // 输入要入队的元素给d
EnQueue(Q,d); // 将d入队
}
m=QueueLength(Q); // m为队列Q的长度
printf("现在队列中的元素为");
QueueTraverse(Q,print); // 从队头到队尾依次对队列Q的每个元素调用函数print()
printf("共向队尾插入了%d个元素。",i+MAX_QSIZE);
if(m-2>0)
printf("现在由队头删除%d个元素，",m-2);
while(QueueLength(Q)>2)
{ DeQueue(Q,d); // 删除队头元素，其值赋给d
printf("删除的元素值为%d，",d);
}
j=GetHead(Q,d); // 将队头元素赋给d
if(j) // 队列Q不空
printf("现在队头元素为%d\n",d);
ClearQueue(Q); // 清空队列Q
printf("清空队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
DestroyQueue(Q); // 销毁队列Q
}
④ 数据结构与算法分析 —— C 语言描述：开放寻址法
分离链接散列算法的缺点是需要指针，由于给新单元分配地址需要时间，因此这就导致算法的速度多少有些缓慢，同时算法实际上还要求实现另一种数据结构。除使用链表解决冲突外，开放寻址散列法（open addressing hashing）是另外一种用链表解决冲突的方法。在开放寻址散列算法系统中，如果有冲突发生，那么就要尝试选择另外的单元，直到找出空的单元为止。更一般地，单元 相继试选，其中 ，且 。函数 F 是冲突解决方法，因为所有的数据都要置入表内，所以开放寻址散列法所需要的表要比分离链接散列用的表大。一般说来，对开放寻址散列算法来说，装填因子应该低于 。开放寻址散列法有三种常用的冲突解决办法：
在线性探测法中，函数 F 是 的线性函数，典型的情形是 。这相当于逐个探测每个单元（必要时可以绕回）以查找出一个空空单元。即插入一个第一个冲突关键字，它将被放入下一个空闲地址，即地址 0，该地址是开放的。之后插入的冲突关键字，会对表进行试选，只要表足够大，总能够找到一个自由单元，但是如此花费的时间是相当多的。更糟的是，即使表相对较空，这样占据的单元也会开始形成一些区块，其结果称为一次聚集（primary clustering），于是，散列到区块中的任何关键字都需要多次试选单元才能解决冲突，然后该关键字被添加到相应的区块中。
可以证明，使用线性探测的预期探测次数对于插入和不成功的查找来说大约为 ，而对于成功的查找来说则是 。略加思考不难得出，成功查找应该比不成功查找平均花费较少的时间。
如果聚算不算是问题，那么对应的公式就不难得到。我们假设有一个很大的表，并设每次探测都与前面的探测无关。对于随机冲突解决办法而言，这些假设是成立的，并且当 不是非常接近 1 时也是合理的。首先，我们导出在一次不成功查找中探测的期望次数，而这正是直到我们找到一个空单元的探测次数。由于空单元所占的份额为 ，因此我们预计要探测的单元数是 。一次成功查找的探测次数等于该特定元素插入时所需要的探测次数。当一个元素被插入时，可以看成是一次不成功查找的结果。因此，我们可以使用一次不成功查找的开销来计算一次成功查找的平均开销。
需要指出， 在 0 到当前值之间的变化，因此早期的插入操作开销较少，从而降低平均开销。我可以通过使用积分计算插入时间平均值的方法来估计平均值，如此得到
这些公式显然优于线性探测相应的公式，聚集不仅是理论上的问题，而且实际上也发生在具体的实现中。线性探测的预计探测次数与 呈正比，即 越小，插入操作平均次数越少。
平方探测是消除线性探测中一次聚集问题的冲突解决办法。平方探测就是冲突函数为二次函数的探测方法。流行的选择是 。
对于线性探测，让元素几乎填满散列表并不是个好主意，因为此时表的性能会降低。对于平方探测情况甚至更糟：一旦表被填满超过一半，当表的大小不是素数时甚至在表被填满超过一半之前，就不能保证一次找到一个空单元了。这是因为最多有一半的表可以用作解决冲突的备选位置。
定理：如果使用平方探测，且表的大小是素数，那么当表至少有一半是空的时候，总能够插入一个新的元素。
哪怕表有比一半多一个的位置被填满，那么插入都有可能失败（虽然这是非常难以见到的，但是把它记住很重要。）。另外，表的大小是素数也非常重要，如果表的大小不是素数，则备选单元的个数可能会锐减。
在开放寻址散列表中，标准的删除操作不能施行，因为相应的单元可能已经引起过冲突，元素绕过它存在了别处。例如，如果我们删除一个冲突的中间元素，那么实际上所有其他的 Find 例程都将不能正确运行。因此，开放寻址散列表需要懒惰删除，虽然在这种情况下并不存在真正意义上的懒惰。
开放寻址散列表的类型声明如下，这里，我们不用链表数组，而是使用散列表项单元的数组，与在分离链接散列中一样，这些单元也是动态分配地址的。
初始化开放寻址散列表的例程如下，由分配空间（第1～10行）及其后将每个单元的 Info 域设置为 Empty 组成。
使用平方探测散列法的 Find 例程如下。如果分裂链接散列法一样， 将返回 Key 在散列表中的位置。如果 Key 不出现，那么 Find 将返回最后的单元。该单元就是当需要时，Key 将被插入的地方。此外，因为被标记了 Empty，所以表达 Find 失败很容易。为了方便起见，我们假设散列表的大小至少为表中元素个数的两倍，因此平方探测方法总能够实现。否则，我们就要在第 4 行前测试 。在下面的例程中，标记为删除的那些元素被认为还在表内，这可能引起一些问题，因为该表可能提前过满。
第 4～6 行为进行平方探测的快速方法。由平方解决函数的定义可知， ，因此，下一个要探测的单元可以用乘以 2（实际上就是进行一位二进制移位）并减 1 来确定。如果新的定位越过数组，那么可以通过减去 TableSize 把它拉回到数组范围内。这比通常的方法要快，因为它避免了看似需要的乘法和除法。注意一条重要的警告：第 3 行的测试顺序很重要，切勿改变它。
下面的例程是插入。正如分离链接散列方法那样，若 Key 已经存在，则我们就什么也不做。其他工作只是简单的修改。否则，我们就把要插入的元素放在 Find 例程指出的地方。
虽然平方探测排除了一次聚集，但是散列到同一位置上的那些元素将探测相同的备选单元。这叫做二次聚集（secondary clustering）。二次聚集是理论上的一个小缺憾，模拟结果指出，对每次查找，它一般要引起另外的少于一半的探测。
双散列（double hashing）能够解决平方探测中的二次聚集问题，不过也需要花费另外的一些乘法和除法形销。对于双散列，一种流行的选择是 。这个公式是说，我们将第二个散列函数应用到 X 并在距离 , 等处探测。 选择的不好将会是灾难性的。
在双散列时，保证表的带下为素数是非常重要的。假设我们在插入一个关键字的时候，发现它已经引发冲突，就会选择备选位置，如果表的大小不是素数，那么备选单元就很有可能提前用完。然后，如果双散列正确实现，则模拟表明，预期的探测次数几乎和随机冲突解决方法的情形相同。这使得双散列理论上很有吸引力，不过，平方探测不需要使用第二个散列函数，从而在实践中可能更简单并且更快。
⑤ C语言数据结构的一个顺序表算法,求分析bug
#include<stdio.h>
typedef int datatype;
const int maxsize=100; //modify
typedef struct{
datatype data[maxsize];
int n;
}sqlist;
int main()
{
//在一个递增数列中插入一个x后仍是一个递增数列
sqlist L;
sqlist *p;
p=&L;
int insert(sqlist *L,datatype x,int i);
int locate(sqlist *L,datatype x);
void print(sqlist *L);
datatype x;
int j;
int i;
printf("input the number of the sqlist's length\n");
scanf("%d",&j);
p->n=j;
for(i=0;i<j;i++)//输入数列
scanf("%d",&p->data[i]);
printf("input the x");
scanf("%d",&x);//插入x
insert(p,x,locate(p,x)) ;
print(p);//输出
return 0;
}
int insert(sqlist *L,datatype x,int i) {
//将x插入到顺序表L的第i个位置上
int j;
if(L->n==maxsize)
{return -1;}
if(i<1 || i>L->n+1)
{return 0;}
for(j=L->n;j>=i;j--)
L->data[j]=L->data[j-1]; //结点后移
L->data[i-1]=x;//插入x，第i个结点的数组下标是i-1
L->n++; //修改表长
return 1; //插入成功
}
int locate(sqlist *L,datatype x) {
int i;
i=1;
while(i<=L->n && L->data[i-1]<=x) i++;
if(i<=L->n) return i; //找到
else return L->n; //未找到
}
void print(sqlist *l){
for(int i=0;i<l->n;i++)
printf("%d ",l->data[i]);
}
⑥ 数据结构与算法分析 C++
你说的是中序线索二叉树的插入和删除
#include<stdio.h>
#include"malloc.h"
#include"windows.h"
#definemaxsize20//规定树中结点的最大数目
typedefstructnode{//定义数据结构
intltag,rtag;//表示child域指示该结点是否孩子
chardata;//记录结点的数据
structnode*lchild,*rchild;//记录左右孩子的指针
}Bithptr;
Bithptr*Q[maxsize];//建队，保存已输入的结点的地址
Bithptr*CreatTree(){//建树函数，返回根指针
charch;
intfront,rear;
Bithptr*T,*s;
T=NULL;
front=1;rear=0;//置空二叉树
printf("建立一棵二叉树，请输入结点信息： ");
printf("请输入新的结点信息，@为空结点，#为结束标志：");
ch=getchar()();//输入第一个字符
while(ch!='#')//判断是否为结束字符
{
s=NULL;
if(ch!='@')//判断是否为虚结点
{
s=(Bithptr*)malloc(sizeof(Bithptr));
s->data=ch;
s->lchild=NULL;
s->rchild=NULL;
s->rtag=0;
s->ltag=0;
}
rear++;
Q[rear]=s;//将结点地址加入队列中
if(rear==1)T=s;//输入为第一个结点为根结点
else
{
if(s!=NULL&&Q[front]!=NULL)//孩子和双亲结点均不是虚结点
if(rear%2==0)
Q[front]->lchild=s;
elseQ[front]->rchild=s;
if(rear%2==1)front++;
}getchar()();
printf("请输入新的结点信息，@为空结点，#为结束标志：");
ch=getchar()();
}
returnT;
}
voidInorder(Bithptr*T)//中序遍历
{
if(T)
{
if(T->ltag!=1)Inorder(T->lchild);
printf("→%c",T->data);
if(T->rtag!=1)Inorder(T->rchild);
}
}
Bithptr*pre=NULL;
voidPreThread(Bithptr*root)//中序线索化算法，函数实现
{
Bithptr*p;
p=root;
if(p){
PreThread(p->lchild);//线索化左子树
if(pre&&pre->rtag==1)pre->rchild=p;//前驱结点后继线索化
if(p->lchild==NULL)
{
p->ltag=1;
p->lchild=pre;
}
if(p->rchild==NULL)//后继结点前驱线索化
p->rtag=1;
pre=p;
PreThread(p->rchild);
}
}
voidPrintIndex(Bithptr*t)//输出线索
{
Bithptr*f;
f=t;
if(f)
{
if(f->ltag==1&&f->lchild==NULL&&f->rtag==1)printf("【%c】",f->data);//如果是第一个结点
if(f->ltag==1&&f->lchild!=NULL)printf("%c→【%c】",f->lchild->data,f->data);//如果此结点有前驱就输出前驱和此结点
if(f->ltag==1&&f->rtag==1&&f->rchild!=NULL)printf("→%c",f->rchild->data);//如果此结点有前驱也有后继，就输出后继
elseif(f->rtag==1&&f->rchild!=NULL)printf("【%c】→%c",f->data,f->rchild->data);//如果没有前驱，就输出此结点和后继
printf(" ");
if(f->ltag!=1)PrintIndex(f->lchild);
if(f->rtag!=1)PrintIndex(f->rchild);
}
}
Bithptr*SearchChild(Bithptr*point,charfindnode)//查找孩子结点函数
{
Bithptr*point1,*point2;
if(point!=NULL)
{
if(point->data==findnode)returnpoint;
else
if(point->ltag!=1){point1=SearchChild(point->lchild,findnode);if(point1!=NULL)returnpoint1;}
if(point->rtag!=1){point2=SearchChild(point->rchild,findnode);if(point2!=NULL)returnpoint2;}
returnNULL;
}
else
returnNULL;
}
Bithptr*SearchPre(Bithptr*point,Bithptr*child)//查找父亲结点函数
{
Bithptr*point1,*point2;
if(point!=NULL)
{
if((point->ltag!=1&&point->lchild==child)||(point->rtag!=1&&point->rchild==child))returnpoint;//找到则返回
else
if(point->ltag!=1)
{
point1=SearchPre(point->lchild,child);
if(point1!=NULL)
returnpoint1;
}
if(point->rtag!=1)
{
point2=SearchPre(point->rchild,child);
if(point2!=NULL)
returnpoint2;
}
returnNULL;
}
else
returnNULL;
}
voidInsert(Bithptr*root)
{
charch;
charc;
Bithptr*p1,*child,*p2;
printf("请输入要插入的结点的信息:");
scanf("%c",&c);
scanf("%c",&c);
p1=(Bithptr*)malloc(sizeof(Bithptr));//插入的结点信息
p1->data=c;
p1->lchild=NULL;
p1->rchild=NULL;
p1->rtag=0;
p1->ltag=0;
printf("输入查找的结点信息:");
scanf("%c",&ch);
scanf("%c",&ch);
child=SearchChild(root,ch);//查孩子结点的地址
if(child==NULL){
printf("没有找到结点 ");
system("pause");
return;
}
elseprintf("发现结点%c ",child->data);
if(child->ltag==0)//当孩子结点有左孩子的时候
{
p2=child;
child=child->lchild;
while(child->rchild&&child->rtag==0)//找到左子树下，最右结点
child=child->rchild;
printf("发现结点%c ",child->data);
p1->rchild=child->rchild;//后继化
p1->rtag=1;
child->rtag=0;
child->rchild=p1;//连接
p1->lchild=child;//前驱化
p1->ltag=1;
}
else//当孩子结点没有左孩子的时候
{
p1->lchild=child->lchild;//前驱化
child->ltag=0;
p1->ltag=1;
child->lchild=p1;
p1->rchild=child;
p1->rtag=1;
}
printf(" 插入结点操作已经完成，并同时完成了线索化的恢复 ");
}
⑦ C语言编写数据结构查找算法
实验五 查找的实现
一、 实验目的
1．通过实验掌握查找的基本概念；
2．掌握顺序查找算法与实现；
3．掌握折半查找算法与实现。
二、 实验要求
1． 认真阅读和掌握本实验的参考程序。
2． 保存程序的运行结果，并结合程序进行分析。
三、 实验内容
1、建立一个线性表，对表中数据元素存放的先后次序没有任何要求。输入待查数据元素的关键字进行查找。为了简化算法，数据元素只含一个整型关键字字段，数据元素的其余数据部分忽略不考虑。建议采用前哨的作用，以提高查找效率。
2、查找表的存储结构为有序表，输入待查数据元素的关键字利用折半查找方法进行查找。此程序中要求对整型量关键字数据的输入按从小到大排序输入。
一、顺序查找
顺序查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请输入您想输入的%d个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
inti=0;
s->r[s->length].key=k;
while(s->r[i].key!=k)
{
i++;
}
if(i==s->length)
{
printf("该表中没有您要查找的数据！\n");
return-1;
}
else
returni+1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;
}
顺序查找的运行结果：
二、折半查找
折半查找代码：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("请输入您要输入的数据的个数:\n");
scanf("%d",&(s->length));
printf("请由大到小输入%d个您想输入的个数据;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所输入的数据为:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
intlow,mid,high;
low=0;
high=s->length-1;
while(low<=high)
{
mid=(low+high)/2;
if(s->r[mid].key==k)
returnmid+1;
elseif(s->r[mid].key>k)
high=mid-1;
else
low=mid+1;
}
printf("该表中没有您要查找的数据!\n");
return-1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("请输入您想要查找的数据的关键字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的数据的位置为:\n\n%d\n\n",keyplace);
return2;
}
折半查找运行结果：
三、实验总结：
该实验使用了两种查找数据的方法（顺序查找和折半查找），这两种方法的不同之处在于查找方式和过程不同，线性表的创建完全相同，程序较短，结果也一目了然。