㈠ 求数据结构试验 线性表的顺序存储结构
#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);
㈡ 数据结构实验 线性表中顺序存储结构的基本操作算法（建顺序表，查询，插入，删除，遍历）
有序线性表插入一个数依然有序
#include<stdio.h>
#define MAXSIZE 6
typedef char datatype;
typedef struct SeqList
{
datatypedata[MAXSIZE];
int last;
}SeqList;
SeqList *init_SeqList()
{
SeqList *L;
L=(SeqList*)malloc(sizeof(SeqList));
L->last=-1;
return L;
}
int main()
{ SeqList *L;
int k,x,j;
intInser_SeqList(SeqList *L);
L->last=0;
L=init_SeqList();
for(k=0;k<(MAXSIZE-1);k++)
{ scanf("%d",&x);
L->data[k]=x;
L->last++;
}
Inser_SeqList(L);
for(j=0;j<L->last;j++)
printf("%d",L->data[j]);
return 0;
}
int Inser_SeqList(SeqList *L)
{
int j,x;
if(L->last==MAXSIZE-1)
{printf("表满");
return (-1);
}
L->last++;
for(j=L->last;j>=0;j--)
if(L->data[j]<x)
L->data[L->last]=x;
else
L->data[j+1]=L->data[j];
return 1;
}
你好，上面是我的程序：符合你的1 2 4点 查询、删除操作在课本里找到 写入即可 谢谢
㈢ 线性表顺序存储结构及其有关算法的实现
将顺序表初始化为5个元素,在结构中定义了顺序表的长度,int length:所以在主函数中可以直接调用用printf(
㈣ 线性表两种 存储结构各自的优缺点有哪些
线性表的链式存储结构：
优点：
插入和删除不需要移动插入时只需要对插入位置后的一个元素进行操作，不需要大量的移动元素。空间有效利用高。
缺点：
大量访问操作时不如顺序存储结构，因为每次都需要从头开始遍历整个线性表直到找到相应的元素为止。
线性表的顺序存储结构：
优点：
可随机存取表中任一元素。因为有下标可以操作可以快速的定位到指定位置的元素，但是不知道位置的话也需要顺序遍历。
缺点：
插入或删除操作时，需大量移动元素。合适在很少进行插入和删除运算的情况下。
(4)线性表顺序存储结构调试分析扩展阅读：
线性表的特征
集合中必存在唯一的一个“第一元素”。
集合中必存在唯一的一个 “最后元素” 。
除最后一个元素之外，均有唯一的后继(后件)。
除第一个元素之外，均有唯一的前驱(前件)。
线性表的基本操作
MakeEmpty(L) 这是一个将L变为空表的方法。
Length（L） 返回表L的长度，即表中元素个数。
Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）。
Prior（L，i） 取i的前驱元素。
Next（L，i） 取i的后继元素。
Locate（L，x） 这是一个函数，函数值为元素x在L中的位置。
Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置。
Delete（L，p） 从表L中删除位置p处的元素。
IsEmpty(L) 如果表L为空表(长度为0)则返回true，否则返回false。
Clear（L）清除所有元素。
Init（L）同第一个，初始化线性表为空。
Traverse（L）遍历输出所有元素。
Find（L，x）查找并返回元素。
Update（L，x）修改元素。
Sort（L）对所有元素重新按给定的条件排序。
strstr(string1,string2)用于字符数组的求string1中出现string2的首地址。
参考资料来源：网络-线性表
㈤ 一、实验目的 1．掌握用 C语言调试程序的基本方法。 2．掌握线性表的基本运算，如插入、删除等。 二、实验
#include
<stdio.h>
#include
<stdlib.h>
#define
MAXSIZE 20
typedef
int ElemType;
typedef
struct
{
ElemType a[MAXSIZE];
int
length;
}SqList;
SqList
a,b,c;
void
creat_list(SqList *L);
void
out_list(SqList L);
void
insert_sq(SqList *L,int i,ElemType e);
int
locat_sq(SqList L,ElemType e);
void
DeleteList(SqList *L,int i)
;
main()
{
int i,k,loc; ElemType e,x;
do
{ printf("\n\n\n");
printf("\n
1. creat " );
printf("\n
2. insert");
printf("\n
3. delete");
printf("\n
4. find");
printf("\n
5. end");
printf("\n***************");
printf("\n
input:1-5");
scanf("%d",&k);
switch(k)
{
case 1:{ creat_list(&a); out_list(a);} break;
case
2:{ printf("\n i,e=?"); scanf("%d,%d",&i,&e);
insert_sq(&a,i,e);
out_list(a);
}
break;
case
3:{ printf("\n i=?"); scanf("%d",&i);
DeleteList(&a,i);
out_list(a);
}
break;
case
4:{ printf("\n e=?"); scanf("%d",&e);
loc=locat_sq(a,e);
if
(loc==-1) printf("\n not find
%d",loc);
else
printf("\n find wei shi
%d",loc);
}
break;
}
/* switch */
}while(k!=5);
printf("\n
byebye");
printf("\n
enter,return");
}
void
creat_list(SqList *L)
{
int i;
printf("\n
n=?"); scanf("%d",&L->length);
for(i=0;i<L->length;i++){
printf("\t data %d=?",i);
scanf("%d",&(L->a[i]));
}
}
/* creat_list */
void
out_list(SqList L)
{
int i; char ch;
printf("\n");
for(i=0;i<=L.length-1;i++)
printf("%10d",L.a[i]);
printf("\n\n
");
}
/* out_list */
void
insert_sq(SqList *L,int i,ElemType e)
{
int j;
if
(L->length==MAXSIZE) printf("\n overflow !");
else
if(i<1||i>L->length+1) printf("\n erroe i !");
else
{ for(j=L->length-1; j>i-1; j--) L->a[j+1]=L->a[j];
L->a[j+1]=e;
L->length++;}
}
/* insert_sq */
int
locat_sq(SqList L, ElemType e)
{
int i=0;
while(i<=L.length-1
&& L.a[i]!=e) i++;
if(i<=L.length-1)
return(i+1);
else
return(-1);
}/*
locat_sq */
void
DeleteList(SqList *L,int i)
{
}
㈥ C语言 数据结构高手进来看一下关于“线性表的顺序存储”问题
l = malloc(sizeof(seqlist));
memset(l,0,sizeof(seqlist));
把这句加在main里面的变量申明后，其他函数调用前
还有你insett函数里面有时候用L有时候用l要一致，还有引号要是英文格式的
㈦ 跪求C数据结构高手帮忙~~线性表的顺序存储及其操作
#include
#include
#define
LIST_INIT_SIZE
100
#define
LISTINCREMENT
10
typedef
struct{
int
*
elem;
int
length;
int
listsize;
}SqList;
//SqList
sq;
void
InitList_Sq(SqList
*sq)
//
初始化列表
{
sq->elem=(int
*)malloc(LIST_INIT_SIZE*sizeof(int));
sq->length=0;
sq->listsize=LIST_INIT_SIZE;
printf("---申请空间成功---!\n");
}
void
GetElem(SqList
*sq,int
i)//获取第i位置元素的值
{
int
*p;
p=&(sq->elem[i-1]);
printf("%d",*p);
printf("\n");
}
int
ListInsert_Sq(SqList
*sq,int
i,int
a)//在i位置之前插入a
{
int
*p,*q;
if(i<=0||i>sq->length+1)
{
printf("---位置不合法---!\n");
return
0;
}
if(sq->length>=sq->listsize)
{
int*
newbase=(int
*)realloc(sq->elem,(sq->listsize+LISTINCREMENT)*sizeof(int));
if(!newbase)
{
printf("申请空间溢出\n");
return
0;
}
sq->elem=newbase;
sq->listsize+=LISTINCREMENT;
}
p=&(sq->elem[i-1]);//p指向第i位置的元素
q=&(sq->elem[sq->length-1]);//q指向最后一个元素
for(;q>=p;--q)
*(q+1)=*q;
*p=a;
++sq->length;
return
1;
}
int
ListDelete_Sq(SqList
*sq,int
i)
//删除i位置上的值
{
int
*p,*q;
if(i<1||i>sq->length)
return
0;
p=&(sq->elem[i-1]);//p指向第i位置的元素
q=sq->elem+sq->length-1;//q指向最后一个元素
for(++p;p<=q;++p)
{
*(p-1)=*p;
}
--sq->length;
return
1;
}
void
visit(SqList
*sq)//输出数据
{
int
i=1;
for(;i<=sq->length;i++)
{
int
*p;
p=&sq->elem[i-1];
printf("%d",*p);
printf("
");
}
}
void
main()
{
int
i=1,a=0,boo=1,number=0;
SqList
s,*sq;
sq=&s;
InitList_Sq(sq);
printf("初始化空表\n");
printf("
输入数据
个数\n");
scanf("%d",&number);
printf("输入%d个数据",number);
printf("\n");
for(;i<=number;i++)
{
scanf("%d",&a);
if(boo=ListInsert_Sq(sq,i,a))
{
printf("---插入成功！---\n");
}
else
{
printf("---插入不成功,重新插入---！\n");
i=i-1;
}
}
printf("输出所有元素\n");
visit(sq);
printf("\n");
printf("输出删除的位置:");
scanf("%d",&a);
if(boo=ListDelete_Sq(sq,a))
{
printf("---数据删除成功！---\n");
}else
{
printf("---没有删除成功---\n");
}
printf("输出所有元素\n");
visit(sq);
printf("\n");
printf("输出要显示数据的位置：");
scanf("%d",&a);
printf("输出%d位置数值\n",a);
if(a<0||a>sq->length)
{
printf("---输出位置的数据不存在---\n");
}
else
{
GetElem(sq,a);
}
}
㈧ 实验一 线性表应用 (原创） 一. 实验目的 1、 掌握用C++上机调试线性表的基本方法； 2、 掌握线性表的基本
从哲学的角度讲，每个人都像磁带一样有两面性。比如你，一面是B面，另一面也是B面。
㈨ 用顺序存储结构编写一算法，将线性表就地逆置，并分析算法的时间效率和空间效率
设线性表中有n个元素，从第1个元素开始向后遍历，直到第n/2个元素为止，当遍历到第i个元素时，将它与第n-i+1个元素互换位置，比如第1个元素就和第n-1+1=n个元素互换位置。算法分析：只需遍历n/2个元素，因此时间复杂度o(n)，属于线性时间复杂度。空间占用方面，只在交换时用到一个临时存贮空间，因此为o(1)，属于常量空间复杂度
㈩ 线性表的两种存储结构各有哪些优缺点
线性表具有两种存储结构即顺序存储结构和链接存储结构。
线性表的顺序存储结构可以直接存取数据元素，方便灵活、效率高，但插入、删除操作时将会引起元素的大量移动，因而降低效率
而在链接存储结构中内存采用动态分配，利用率高，但需增设指示结点之间关系的指针域，存取数据元素不如顺序存储方便，但结点的插入、删除操作较简单。