A. 线性表的顺序存储实验
你改下下面代码的标点就行了：
#include<iostream.h>
#define elemtype int
struct link
{ elemtype data；//元素类型
link *next； //指针类型，存放下一个元素地址
};
//头插法建立带头结点的单链表
link *hcreat()
{ link s,p;
elemtype i;
cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；
cin>>i；
p=new link；
p->next=NULL；
while(i) //当输入的数据不为0时，循环建单链表
{s=new link；
s->data=i；
s->next=p->next；
p->next=s；
cin>>i； }
return p；
}
//输出单链表
void print(1ink *head)
{
1ink *p；
p=head->next；
while(p->next!=NULL)
{
cout<<p->data<<”->”； //输出表中非最后一个元素
p=p->next；
}
cout<<p->data； //输出表中最后一个元素
cout<<endl；
}
∥在单链表head中查找值为x的结点
Link *Locate(1ink *head，elemtype x)
{
Link *p；
p=head->next；
while((p!=NULL)&&(p->data!=x))
p=p->next；
return p； }
//在head为头指针的单链表中，删除值为x的结点
void deletel(1ink *head，elemtype x)
{
1ink *p， *q；
q=head；
p=head->next；
while((p!=NULL)&&(p->data!=x))
{
q=p；
p=p->next；}
If(p==NULL) cout<<“要删除的结点不存在”；
else
q->next=p ->next；
delete(p)；
}
}
//在头指针head所指的单链表中，在值为x的结点之后插入值为y的结点
void insert(1ink *head，elemtype x，elemtype y)
｛ link *p， *s；
s=new link；
s->data=y；
if(head->next==NULL) //链表为空
{
head->next=s；
s->next=NULL：
}
p=Locate(head，x)；//调用查找算法 ‘
if(p==NULL)
cout<<”插入位置非法”：
else
(s->next=p->next；
p->next=s；
}
}
//将单链表p中所有值为x的元素修改成y
void change(1ink *p,elemtype x,elemtype y)
{
link *q；
q=p->next；
while(q!=NULL)
{ if(q->data==x) q->data=y；
q=q->next；
}
}
void count(1ink *h) //统计单链表中结点个数
{
1ink *p；int n=0；
p=h->next；
while(p!=NULL)
{n++；p=p->next；}
return n;
}
void main()
{ int n；
elemtype x，y；
link *p， *q；
p=hcreat()； //头插法建立链表
print(p)； //输出刚建立的单链表
cout<<”请输入要删除的元素”；
cin>>y；
deletel(p，y)；
print(p)； //输出删除后的结果
cout<<”请输入插入位置的元素值(将待插元素插入到它的后面)”;
cin>>x；
cout<<”请输入待插元素值”；
cin>>y；
insert(p，x，y)；
print(p)； //输出插入后的结果
cout<<”请输入要修改前、后的元素值”;
cin>>x>>y；
change(p，x，y)；
print(p)；
cout<<”请输入要查找的元素值”；
cin>>x；
q=Locate(p，x)；
if(q==NULL)cout<<x<<”不在表中，找不到!”<<endl；
else cout<<x<<”在表中，已找到!”<<endl；
n=count(p)；
cout<<”链表中结点个数为：”<<n<<endl：
}
B. 已知线性表L=(10, 15, 30, 42, 51, 62), 请分别画出该线性表的顺序存储结构和链式存储结构。
不是很懂你的意思，线性表顺序存储是连续的，把数据写在连续的空间就是，而链式存储不连续，把数据分多个空间就是
C. 求数据结构试验 线性表的顺序存储结构
#include<iostream.h>
#include<stdlib.h>
#include <malloc.h>
#define OVERFLOW 0
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100//线性表存储空间的初始增量
#define LISTINCREMENT 10 // ?
typedef struct{
int * elem;// 存储空间基址
int length;//当前长度
int listsize;//当前分配的存储容量
}SqList;
SqList L;
int InitList_Sq(SqList & L){
//构造一个新的线性表。
L.elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L.elem)exit(OVERFLOW);//存储容量失败
L.length=0; //空表长度为0
L.listsize=LIST_INIT_SIZE;//存储初始容量
return OK;
}//InitList_Sq
int LIstInsert_Sq(SqList & L,int i,int e){
//在顺序线性表L中第i位置之前插入新的元素e
if(i<1||i>L.length+1) return ERROR;
if(L.length>=L.listsize){
int * newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));
if(!newbase)exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
int * q=&(L.elem[i-1]);
for(int * p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
int ListDelete_Sq(SqList&L,int i,int &e)
{
if((i<1)||(i>L.length))return ERROR;
int *p=&(L.elem[i-1]);
e=*p;
int *q=L.elem+L.length-1;
for(++p;p<=q;++p)*(p-1)=*p;
--L.length;
return OK;
}
void main()
{
SqList L;
int i,n;
int e;
cout<<"输入顺序表的个数："<<endl;
cin>>n;
int *p=(int *)malloc(n*sizeof(int));
InitList_Sq(L);
cout<<"输入线性表"<<n<<"个元素的值"<<endl;
for(i=0;i<n;i++)
{
cin>>p[i];
L.elem[i]=p[i];
}
cout<<endl;
L.length=i;
cout<<endl;
cout<<"输入要插入元素的值"<<endl;
cin>>e;
cout<<endl;
cout<<"输入要插入的位置"<<endl;
cin>>i;
LIstInsert_Sq( L, i, e);
for(i=0;i<n+1;i++)
cout<<L.elem[i];
cout<<endl;
cout<<"输入要删除的位置"<<endl;
cin>>i;
ListDelete_Sq(L,i,e)
;for(i=0;i<n;i++)
cout<<L.elem[i];
free(p);
D. 试分别画出在线性表(a,b,c,d,e,f,g)中进行折半查找,查找关键字e,和g的过程。
解题如下：
(1)查e
Step1: a b c d e f g
↑ ↑ ↑
low mid high d<e low=mid + 1;
Step2: a b c d e f g
↑ ↑ ↑
low mid high f>e high=mid – 1;
Step 3: a b c d e f g
↑
low/high
mid e==e return mid ;
(2)查f
Step 1: a b c d e f g
↑ ↑ ↑
low mid high d<f low=mid + 1;
Step 2: a b c d e f g
↑ ↑ ↑
low mid high f==f return mid;
(3)查g
Step 1: a b c d e f g
↑ ↑ ↑
low mid high d<g low=mid + 1;
Step 2: a b c d e f g
↑ ↑ ↑
low mid high f<g low=mid + 1;
Step 3: a b c d e f g
↑
low/high
mid g==g return(mid);
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。
线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。
在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。
线性表中的个数n定义为线性表的长度，n=0时称为空表。在非空表中每个数据元素都有一个确定的位置，如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。
线性表的相邻元素之间存在着序偶关系。如用（a1，…，ai-1，ai，ai+1，…，an）表示一个顺序表，则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。当i=1,2，…，n-1时，ai有且仅有一个直接后继，当i=2，3，…，n时，ai有且仅有一个直接前驱 。
(4)画线性表顺序存储示意图扩展阅读：
线代表存储结构
线性表主要由顺序表示或链式表示。在实际应用中，常以栈、队列、字符串等特殊形式使用。
顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，称为线性表的顺序存储结构或顺序映像。它以“物理位置相邻”来表示线性表中数据元素间的逻辑关系，可随机存取表中任一元素。
链式表示指的是用一组任意的存储单元存储线性表中的数据元素，称为线性表的链式存储结构。它的存储单元可以是连续的，也可以是不连续的。
在表示数据元素之间的逻辑关系时，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置），这两部分信息组成数据元素的存储映像，称为结点。它包括两个域；存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指针域。指针域中存储的信息称为指针或链
E. 已知线性表L=(10,15,30,42,51,62)请分别画出该线性表的顺序储存结构和链式储存结构。请帮我画出来。
这是线性表的顺序存储结构，请采纳，好不容易写的，链式就不写了，可以查资料！
F. 给出三元组线性表的顺序存储表示
这很简单的问题啊... #define MaxSize 100 typedef char ElemType typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 }; //顺序表的类型定义
G. 关于线性表的顺序存储结构，高手帮下~~
数位顺序表 数位是指各个计数单位所占的位置，如万所占的位置是万位。每个数位上的数都有相对应的计数单位，如个位的计数单位是个，十位的计数单位是十 整数数位顺序表 数级 亿级 万级 个级 数位 千亿位 百亿位 十亿位 亿位 千万位 百万位 十万位 万位 千位 百位 十位 亿级 千亿位 百亿位 十亿位 亿位
万级 千万位 百万位 十万位 万位
个级 千位 百位 十位
每个数位所代表的量 在数位顺序表中，从右边起，第一位是个位，计数单位是一，表示几个一；第二位是十位，计数单位是十，表示几个十；第三位是百位，计数单位是百，表示几个百；第四位是千位，计数单位是千，表示几个千；第五位是万位，计数单位是万，表示几个万。以此类推。 数位顺序表 京 亿兆 万兆 千兆 百兆 十兆 兆 千亿位 百亿位 十亿位 亿位 千万位 百万位 十万位 万位 千位 百位 十位 个位
H. 画出下列广义表的存储结构示意图 A=((a,b,c),d(a,b,c)) B=(a,(b,(c,d)e),f)
A=((a,b,c),d(a,b,c)) B=(a,(b,(c,d)e),f)具体存储结构示意图如下：
使用链表存储广义表，首先需要确定链表中节点的结构。由于广义表中可同时存储原子和子表两种形式的数据，因此链表节点的结构也有两种。
(8)画线性表顺序存储示意图扩展阅读：
由于广义表是对线性表和树的推广，并且具有共享和递归特性的广义表可以和有向图建立对应，因此广义表的大部分运算与这些数据结构上的运算类似。
根据表头、表尾的定义可知：任何一个非空广义表的表头是表中第一个元素，它可以是原子，也可以是子表，而其表尾必定是子表。
I. 数据结构之有序线性表的顺序存储结构
指线性表中的元素按值或者关键字的大小先后有序(升序或者降序）。
之前讲了线性表的顺序存储结构 数据结构之线性表的顺序存储结构
有序线性表是在之前的基础上构建的，相对于之前的线性表的操作，有序线性表增加了如下操作：
有序线性表的接口SortedList
有序线性表的实现类，实现了SortedList和继承了SequenceList（ 数据结构之线性表的顺序存储结构 ）
插入方法
删除方法
查找方法
测试类
J. 如何建立一个顺序存储的线性表，实现线性表的插入、删除操作
顺序存储结构线性表基本操作 C语言实现
#include<stdio.h>
//以下为函数运行结果状态代码
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#defineLIST_INIT_SIZE100//线性表存储空间的初始分配量
#defineLISTINCREMENT10//线性表存储空间分配增量
typedefintStatus;//函数类型，其值为为函数结果状态代码
typedefintElemType;//假设数据元素为整型
typedefstruct
{
ElemType*elem;//存储空间基址
intlength;//当前长度
intlistsize;//当前分配的存储容量
}SqList;
//实现线性表的顺序存储结构的类型定义
//函数声明开始
StatusInitList_Sq(SqList&L);
voidDestroyList_Sq(SqList&L);
voidClearList_Sq(SqList&L);
voidListEmpty_Sq(SqListL);
StatusGetElem_Sq(SqListL,i,&e);
intLocateElem_Sq(SqListL,e,compare());
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusListInsert_Sq(SqList&L,i,e);
StatusListDelete_Sq(SqList&L,i,&e);
ListTravel_Sq(SqListL,visit());
//函数声明结束
intmain(void)
{
return0;
}
//函数定义开始
///////////////////////////////////////
//函数名：InitList_Sq()
//参数：SqList*L
//初始条件：无
//功能：构造一个空线性表
//返回值：存储分配失败：OVERFLOW
//存储分配成功：OK
///////////////////////////////////////
StatusInitList_Sq(SqList*L)
{
L.elem=(ElemType*)malloc((LIST_INIT_SIZE*sizeof(ElemType));//分配空间
if(!L.elem)
exit(OVERFLOW);//若存储分配失败，返回OVERFLOW
L.length=0;//空表，长度为0
L.listsize=LIST_INIT_SIZE;//初始存储容量
returnOK;
}
///////////////////////////////////////
//函数名：DestroyList_Sq()
//参数：SqList*L
//初始条件：线性表L已存在
//功能：销毁线性表
//返回值：无
///////////////////////////////////////
voidDestroyList_Sq(SqList*L)
{
if(L->elem)
free(L->elem);//释放线性表占据的所有存储空间
}
///////////////////////////////////////
//函数名：ClearList_Sq()
//参数：SqList*L
//初始条件：线性表L已存在
//功能：清空线性表
//返回值：无
///////////////////////////////////////
voidClearList_Sq(SqList*L)
{
L->length=0;//将线性表的长度置为0
}
///////////////////////////////////////
//函数名：ListEmpty_Sq()
//参数：SqListL
//初始条件：线性表L已存在
//功能：判断线性表是否为空
//返回值：空：TRUE
//非空：FALSE
///////////////////////////////////////
StatusListEmpty_Sq(SqListL)
{
if(L.length==0)
returnTRUE;
else
returnFALSE;
}
///////////////////////////////////////
//函数名：ListLength_Sq()
//参数：SqListL
//初始条件：线性表L已存在
//功能：返回线性表长度
//返回值：线性表长度(L.length)
///////////////////////////////////////
StatusListLength_Sq(SqListL)
{
return(L.length);
}
///////////////////////////////////////
//函数名：GetElem_Sq()
//参数：SqListL,inti,ElemType*e
//初始条件：线性表L已存在，1<=i<=ListLength(L)
//功能：用e返回线性表中第i个元素的值
//返回值：(i<1)||(i>ListLength(L))：ERROR
//1<=i<=ListLength(L)：OK
///////////////////////////////////////
StatusGetElem_Sq(SqListL,inti,ElemType*e)
{
if(i<1||i>L.length)
returnERROR;//判断i值是否合理，若不合理，返回ERROR
*e=L.elem[i-1];//数组中第i-1的单元存储着线性表中第i个数据元素的内容
returnOK;
}
///////////////////////////////////////
//函数名：LocateElem_Sq()
//参数：L,e,compare(ElemType1,ElemType2)
//初始条件：线性表L已存在，compare()为数据元素判定函数
//功能：返回顺序表L中第1个与e满足关系compare()的数据元素的位序
//返回值：若在L中存在于e满足关系compare()的元素：其位序
//若在L中不存在于e满足关系compare()的元素：0
///////////////////////////////////////
intLocateElem_Sq(SqListL,e,compare(ElemType1,ElemType2))
{
inti=1;//i的初值为第1元素的位序
intp=L.elem;//p的初值为第1元素的存储位置
while(i<=L.length&&!(*compare)(*p++,e))
++i;//依次进行判定
if(i<=L.length)
returni;//找到满足判定条件的数据元素为第i个元素
else
return0;//该线性表中不存在满足判定的数据元素
}
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
//见StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
//我的思路是先用LocateElem_Sq()搜索cur_e的位序，
//再看是否大于等于length，
//若是，则返回OVERFLOW；否则返回后继
//这样也许有点麻烦？所以希望大家能够补充方案
//bywangweinoo1
///////////////////////////////////////
//函数名：ListInsert_Sq()
//参数：SqList*L,inti,ElemTypee
//初始条件：线性表L已存在，1<=i<=ListLength(L)+1
//功能：在线性表中第i个数据元素之前插入数据元素e
//返回值：失败：ERROR
//成功：OK
///////////////////////////////////////
StatusListInsert_Sq(SqList*L,inti,ElemTypee)
{
ElemType*j;
if(L->length==LIST_MAX_LENGTH)
returnERROR;//检查是否有剩余空间
if(i<1||i>L->length+1)
returnERROR;//检查i值是否合理
//将线性表第i个元素之后的所有元素向后移动
for(j=L->length-1;j>=i-1;i++)
L->elem[j+1]=L->elem[j];
L->elem[i-1]=e;//将新元素的内容放入线性表的第i个位置，
L->length++;
returnOK;
}
///////////////////////////////////////
//函数名：ListDelete_Sq()
//参数：SqList*L,inti,Elemtype*e
//初始条件：线性表L已存在，1<=i<=ListLength(L)
//功能：将线性表L中第i个数据元素删除
//返回值：失败：ERROR
//成功：OK
///////////////////////////////////////
intListDelete_Sq(SqList*L,inti,Elemtype*e)
{
if(IsEmpty(L))
returnERROR;//检测线性表是否为空
if(i<1||i>L->length)
returnERROR;//检查i值是否合理
*e=L->elem[i-1];//将欲删除的数据元素内容保留在e所指示的存储单元中
//将线性表第i+1个元素之后的所有元素向前移动
for(j=i;j<=L->length-1;j++)L->elem[j-1]=L->elem[j];
L->length--;
returnOK;
}
//函数定义结束