#include<stdio.h>
#include<stdlib.h>
#define list_init_size 5
#define listincrement 10
#define overflow -2
typedef int status;
typedef int elemtype;
typedef struct
{
elemtype *elem;
int length;
int listsize;
} sqlist;
status initlist_sq(sqlist &L)
{
L.elem=(elemtype *)malloc(list_init_size * sizeof(elemtype));
if(!L.elem) exit(overflow);
L.length=0;
L.listsize=list_init_size;
return 1;
}
将顺序表初始化为5个元素,在结构中定义了顺序表的长度,int length:所以在主函数中可以直接调用用printf("%d",L.length)就得到了当前的长度,无论是删除,添加,L.length都会随着改变,比如我们建一个添加的函数
status listinsert_sq(sqlist &L, int i ,elemtype e)
{
int * q , *p ,* newbase;
if(i<1 || i>L.length + 1) return 0;
if(L.length >= L.listsize)
{
newbase=(elemtype *)realloc(L.elem,(L.listsize+listincrement) * sizeof(elemtype));
if(!newbase) exit (overflow);
L.elem=newbase;
L.listsize+=listincrement;
}
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]) ;p>=q ;--p)
*(p+1) = *p;
*q = e;
++L.length;
return 1;
}
如果加一个元素,就会把L.length自动加1,这样避免了再写函数求表长
② 顺序存储的有序线性表 有序线性链表
“顺序存储”表明该线性表使用顺序存储结构（即数组）
“有序”表明线性表内元素排列有序，如“1，2，3，4，5”
“链表”表明该线性表采用链式存储结构，即每个元素的数据类型都是一个结构体，这个结构体里面又包含指向下一个位置的结构体的地址
顺序存储结构的线性表的类型定义如下：
#define
MAXSIZE
100
‖顺序表的最大容量
typedef
struct
{ElemType
data[MAXSIZE];
‖存放线性表的数组
int
last;
‖last是线性表的长度
}SeqList;
链式存储线性表的结点定义：
typedef
struct
Node
{ElemType
data;
struct
Node
*next;
}LNode，*LinkedList；
③ 线性表 - 顺序存储结构 - 顺序表
顺序表
顺序表的定义
( ) 顺序存储方法
即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法
( ) 顺序表(Sequential List)
用顺序存储方法存储的线性表简称为顺序表(Sequential List)
结点a i 的存储地址
不失一般性 设线性表中所有结点的类型相同 则每个结点所占用存储空间大小亦相同 假设表中每个结点占用c个存储单元 其中第一个单
元的存储地址则是该结点的存储地址 并设表中开始结点a 的存储地址(简称为基地址)是LOC(a ) 那么结点a i 的存储地址LOC(a i
)可通过下式计算
LOC(a i )= LOC(a )+(i )*c ≤i≤n
注意
在顺序表中 每个结点a i 的存储地址是该结点在表中的位置i的线性函数 只要知道基地址和每个结点的大小 就可在相同时间内求出任一结
点的存储地址 是一种 随机存取结构
顺序表类型定义
#define ListSize //表空间的大小可根据实际需要而定 这里假设为
typedef int DataType; //DataType的类型可根据实际情况而定 这里假设为int
typedef struct {
DataType data[ListSize];//向量data用于存放表结点
int length;//当前的表长度
}SeqList;
注意
① 用向量这种顺序存储的数组类型存储线性表的元素外 顺序表还应该用一个变量来表示线性表的长度属性 因此用结构类型来定义顺序表类
型
② 存放线性表结点的向量空间的大小ListSize应仔细选值 使其既能满足表结点的数目动态增加的需求 又不致于预先定义过大而浪费存储
空间
③ 由于C语言中向量的下标从 开始 所以若L是SeqList类型的顺序表 则线性表的开始结点a 和终端结点a n 分别存储在L data[ ]和
L Data[L length ]中
④ 若L是SeqList类型的指针变量 则a 和a n 分别存储在L >data[ ]和L >data[L >length ]中
顺序表的特点
顺序表是用向量实现的线性表 向量的下标可以看作结点的相对地址 因此顺序表的的特点是逻辑上相邻的结点其物理位置亦相邻
lishixin/Article/program/sjjg/201311/23579
④ 求数据结构试验 线性表的顺序存储结构
#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);
⑤ 1、线性表顺序存储方式操作2、线性表链式存储方法操作：。两个都用c语言
下面是从我的博客里面给你找的，你参考一下。更多的数据结构的内容，也可以去看我的博客。
/************************************************************
说明：
1、主函数内的代码是为了测试方便，可以自行修改。
2、宏定义NEWS是人机交互信息提示，若不需要，可修改为0。
3、若是windows系统，请将258行中的clear修改为cls。
4、在输入数据后，请多按一下回车，实现清屏。
环境：ubuntu12.04LTS、codeblocks10.05、2014-04-02
************************************************************/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<cstring>
#defineNEWS1
#defineLIST_INIT_SIZE100
#defineLIST_ADD_SIZE10
#defineNEW_SIZE(L->list_size+LIST_ADD_SIZE)
usingnamespacestd;
typedefintElem_Type;
typedefstruct
{
Elem_Type*data;//元素
intlen;//长度
intlist_size;//空间
}Sq_List;
typedefenum
{
OK=0,//正常
ERROR=-1,//逻辑异常
OVER=-2//内存异常
}Status;
/******************************
函数名：Init_List
功能：构造、初始化线性表
******************************/
Sq_List*Init_List(void)
{
Sq_List*L=(Sq_List*)malloc(sizeof(Sq_List));
if(!L)
exit(OVER);
L->data=(Elem_Type*)malloc(LIST_INIT_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->len=0;
L->list_size=LIST_INIT_SIZE;
#if(NEWS)
cout<<"构造成功，已初始化"<<endl;
#endif
returnL;
}
/******************************
函数名：Destroy_List
功能：销毁线性表
******************************/
StatusDestroy_List(Sq_List*L)
{
free(L);
#if(NEWS)
cout<<"销毁成功，请不要再使用"<<endl;
#endif
returnOK;
}
/******************************
函数名：Clear_List
功能：清空线性表
******************************/
StatusClear_List(Sq_List*L)
{
memset(L->data,-1,sizeof(L->data));
L->len=0;
#if(NEWS)
cout<<"已全部清空"<<endl;
#endif
returnOK;
}
/******************************
函数名：Empty_List
功能：判断线性表是否为空
******************************/
boolEmpty_List(Sq_List*L)
{
returnL->len==0;
}
/******************************
函数名：Length_List
功能：获取线性表长度
******************************/
intLength_List(Sq_List*L)
{
returnL->len;
}
/******************************
函数名：Get_Elem_List
功能：指定位置获取元素
******************************/
StatusGet_Elem_List(Sq_List*L,intindex,Elem_Type*e)
{
if(!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"获取位置不合法"<<endl
<<"下面显示的数据是上次输入的num的值,请注意！！！"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
returnOK;
}
/******************************
函数名：Insert_List
功能：指定位置插入元素
******************************/
StatusInsert_List(Sq_List*L,intindex,Elem_Typee)
{
if(!(1<=index&&index<=Length_List(L)+1))
#if(NEWS)
{
cout<<"插入位置不合法"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
if(Length_List(L)>=L->list_size)
#if(NEWS)
cout<<"刚才增加了存储空间"<<endl;
#endif
L->data=(Elem_Type*)realloc(L->data,NEW_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->list_size+=LIST_ADD_SIZE;
for(inti=Length_List(L);i>=index-1;i--)
L->data[i+1]=L->data[i];
L->data[index-1]=e;
L->len++;
#if(NEWS)
cout<<"插入成功"<<endl;
#endif
returnOK;
}
/******************************
函数名：Delete_List
功能：指定位置删除元素
******************************/
StatusDelete_List(Sq_List*L,intindex,Elem_Type*e)
{
if(Empty_List(L)||!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"删除位置不合法or目前是空表"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
for(inti=index;i<Length_List(L);i++)
L->data[i-1]=L->data[i];
#if(NEWS)
cout<<"删除成功"<<endl;
#endif
L->len--;
returnOK;
}
/******************************
函数名：Print_List
功能：输出所有元素
******************************/
StatusPrint_List(Sq_List*L)
{
if(Empty_List(L))
returnERROR;
inttemp;
for(inti=1;i<=Length_List(L);i++)
{
Get_Elem_List(L,i,&temp);
cout<<temp<<"";
}
cout<<endl;
returnOK;
}
/******************************
函数名：print_news
功能：方便用户选择
******************************/
voidprint_news(void)
{
cout<<"
********************"
<<"*****************************"<<endl
<<" * 0建立、初始化 *"<<endl
<<" * *"<<endl
<<" * 1插入元素 *"<<endl
<<" * *"<<endl
<<" * 2删除元素 *"<<endl
<<" * *"<<endl
<<" * 3销毁 *"<<endl
<<" * *"<<endl
<<" * 4获取表长 *"<<endl
<<" * *"<<endl
<<" * 5清空 *"<<endl
<<" * *"<<endl
<<" * 6获取元素 *"<<endl
<<" * *"<<endl
<<" * 7打印 *"<<endl
<<" * *"<<endl
<<" * 8退出程序 *"<<endl
<<" ********************"
<<"*****************************"<<endl;
}
intmain(void)
{
Sq_List*test=NULL;
while(true)
{
print_news();
intchoose,index,num;
cout<<"要进行什么操作？"<<endl;
cin>>choose;
switch(choose)
{
case0:
test=Init_List();break;
case1:
cout<<"插入位置"<<endl;
cin>>index;
cout<<"插入数据"<<endl;
cin>>num;
Insert_List(test,index,num);break;
case2:
cout<<"删除的位置"<<endl;
cin>>index;
Delete_List(test,index,&num);
cout<<"被删除的元素是："<<num<<endl;break;
case3:
Destroy_List(test);break;
case4:
cout<<Length_List(test)<<endl;break;
case5:
Clear_List(test);break;
case6:
cout<<"获取哪个位置的元素"<<endl;
cin>>index;
Get_Elem_List(test,index,&num);
cout<<num<<endl;break;
case7:
Print_List(test);break;
case8:
return0;
default:
break;
}
getchar();
getchar();
system("clear");
}
return0;
}
⑥ 数据结构之线性表的顺序存储[1]
线性表的顺序存储是线性表的一种最简单最直接的存储结构 它是用内存中的一段地址连续的存储空间顺序存放线性表的每一个元素 用这种存储形式存储的线性表我们称其为顺序表 在顺序表中用内存中地址的线性关系表示线性表中数据元素之间的关系 这种用物理上的相邻关系实现数据元素之间的逻辑相邻关系简单明了 如图 所示 设 e 的存储地址为Loc(e ) 每个数据元素占d个字节存储单元 则第i个数据元素的地址为
Loc(ei)=Loc(e )+(i )*d ≤i≤n
这意味着只要知道顺序表首地址和每个数据元素所占地址单元的个数就可求出第i个数据元素的地址来 所以线性表的顺序存储结构是一种随机存取的存储结构 具有按数据元素的序号随机存取的特点
线性表
顺序表的内存表示
下标
数据元素
存储地址
存储元素
e
数据结构免费提供，内容来源于互联网,本文归原作者所有。
⑦ 线性表的定义是什么它有什么特点它有什么作用
线性表不仅是指在VF中，任何涉及到数据的知识都有线性表：线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。线性表是一种常用的数据结构，以下介绍线性表及其顺序存储，并对栈和队列及它们的顺序实现给出了详细的设计描述。在实际应用中，线性表都是以栈、队列、字符串、数组等特殊线性表的形式来使用的。由于这些特殊线性表都具有各自的特性，因此，掌握这些特殊线性表的特性，对于数据运算的可靠性和提高操作效率都是至关重要的。线性表是一个线性结构，它是一个含有n≥0个结点的有限序列，对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。一般地，一个线性表可以表示成一个线性序列：k1,k2,…,kn，其中k1是开始结点，kn是终端结点。是一个数据元素的有序（次序）集线性结构的基本特征为:1．集合中必存在唯一的一个“第一元素”；2．集合中必存在唯一的一个“最后元素”；3．除最后一个元素之外，均有唯一的后继(后件)；4．除第一个元素之外，均有唯一的前驱(前件)。由n(n≥0)个数据元素(结点)a1,a2,…,an组成的有限序列。数据元素的个数n定义为表的长度。当n=0时称为空表。常常将非空的线性表(n>0)记作：(a1，a2，…an)数据元素ai(1≦i≦n)只是一个抽象的符号，其具体含义在不同的情况下可以不同。线性表的基本操作1）Setnull（L）置空表2）Length（L）求表长度；求表中元素个数3）Get（L，i）取表中第i个元素（1≤i≤n）4）Prior（L，i）取i的前趋元素5）Next（L，i）取i的后继元素6）Locate（L，x）返回指定元素在表中的位置7）Insert（L，i，x）插入元素8）Delete（L，x）删除元素9）Empty（L）判别表是否为空线性表具有如下的结构特点：1.均匀性：虽然不同数据表的数据元素可以是各种各样的，但对于同一线性表的各数据元素必定具有相同的数所类长度。2.有序性：各数据元素在线性表中的位置只取决于它们的序与，数据元素之前的相对位置是线性的，即存在唯一的“第一个“和“最后一个“的数据元素，除了第一个和最后一个外，其它元素前面均只有一个数据元素直接前趋和后面均只有一个数据元素（直接后继）。在实现线性表数据元素的存储方面，一般可用顺序存储结构和链式存储结构两种方法。链式存储结构将在本网站线性链表中介绍，本章主要介绍用数组实现线性表数据元素的顺序存储及其应用。另外栈．队列和串也是线性表的特殊情况，又称为受限的线性结构。
⑧ 1、编写程序实现线性表顺序存储结构的基本操作：初始化、插入、删除、打印、求长度等操作。
/*线性表的操作*/
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
struct List
{
ElemType *list;
int size;
int MaxSize;
};
/*初始化列表,即动态存储空间分配并置L为一个空列表*/
void initList(struct List *L,int ms)
{
if(ms<=0)
{
printf("MaxSize 非法！");
exit(1);
}
L->MaxSize = ms;
L->size = 0;
L->list=malloc(ms * sizeof(ElemType));
if(!L->list)
{
printf("空间分配失败！");
exit(1);
}
/*printf("%d\n",sizeof(ElemType));*//*暂用字节数*/
return ;
}
void againMalloc(struct List *L)
{
ElemType *p = realloc(L->list,2*L->MaxSize*sizeof(ElemType));
if(!p)
{
printf("存储空间分配失败！");
exit(1);
}
L->list = p; /*使list指向新线性表空间*/
L->MaxSize=2 * L->MaxSize; /*把线性空间大小修改为新的长度*/
}
/*向线性表L的表尾插入元素*/
void insertLastList(struct List *L,ElemType x)
{
if(L->size==L->MaxSize){
/*重新分配更大空间*/
/*againMalloc(L);*/
printf("max\n");
}
L->list[L->size]= x ;
L->size++;
printf("x=%d\n" ,x);
return ;
}
/*插入内容*/
int insertPostList(struct List *L,int pos,ElemType x)
{
int i;
if(pos<1 || pos> L->size+1)
{
/* 若Pos越界则插入失败 */
return 0 ;
}
if(L->size==L->MaxSize){
/*重新分配更大的存储空间*/
againMalloc(L);
}
L->list[pos-1] = x;
L->size++;
/* printf("%d\n", L->list[pos-1] ); */
return 1 ;
}
/* 按下标获得元素值 */
ElemType GetElem(struct List *L ,int pos)
{
if(pos<1 || pos>L->size)
{
printf("元素序号越界！");
exit(1);
}
return L->list[pos-1]; /* 返回线性表中序号为Pos值的元素 */
}
/* 顺序扫描（即遍历）输出线性表L中的每个元素 */
void traverseList(struct List *L)
{
int i ;
for(i = 0; i<L->size;i++)
{
printf("%d ",L->list[i]);
}
printf("\n");
return ;
}
/*值与X相等的元素，若查找成功则返回其位置，否则返回-1*/
int findList(struct List *L,ElemType x)
{
int i;
for(i = 0;i<L->size;i++){
if(L->list[i]==x){
return i ;
}
}
return -1 ;
}
/* 把线性表L中第pos个元素的值修改为X的值，若修改成功批回1，否则返回0 */
int updatePostList(struct List *L,int pos,ElemType x)
{
if(pos<1 || pos>L->size){
return 0 ;
}
L->list[pos-1]= x;
return 1 ;
}
/* 从线性表中L删除表头元素并返回它，若删除失败则停止程序运行 */
ElemType deleteFirstList(struct List *L)
{
ElemType temp;
int i ;
if(L->size == 0){
printf("线性表为空，不能进行删除操作！");
exit(1);
}
temp = L->list[0];
for(i = 0 ;i<L->size;i++)
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行 */
ElemType deleteLastList(struct List *L)
{
if(L->size==0){
printf("线性表为空，不能进行删除操作！");
exit(1);
}
L->size--;
/* 返回原来表尾的值 */
return L->list[L->size];
}
/* 从线性表L中删除第pos个元素并返回它，若删除失则停止程序运行 */
ElemType deletePostList(struct List *L ,int pos)
{
ElemType temp;
int i;
if(pos < 1 || pos > L->size){ /* pos越界则删除失败 */
printf("pos值越界，不能进行删除操作！ ");
exit(1);
}
temp = L->list[pos-1];
for(i = pos; i < L->size; i++)
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 返回线性表L当前的长度，若L 为空则返回0 */
int sizeList(struct List *L)
{
return L->size ;
}
/* 是不是一个空列表 */
int EmptyList(struct List *L)
{
if(L->size==0){
return 1;
}
else{
return 0 ;
}
}
/* 清除线性表L中的所有元素，释放存储空间，使之成为一个空表 */
void clearList(struct List *L)
{
if(L->list!=NULL){
free(L->list);
L->list=0;
L->size = L->MaxSize = 0 ;
}
return ;
}
main()
{
int a[10]={2,4,6,8,10,12,14,16,18,20};
struct List L;
int i ;
initList(&L,5);
for(i = 0 ;i<10;i++)
{
insertLastList(&L,a[i]);
}
/* 在当前下标下存入该值 */
insertPostList(&L,11,48);
/* 在当前下标下输入该值 */
insertPostList(&L,3,25);
/* 按下标获得当前下标的值 */
printf("GetElem=%d\n",GetElem(&L,11));
/* 输出当前列表中的所有数据 */
traverseList(&L);
/* 查询与 当前指标的值 */
printf("%d\n",findList(&L,8));
/* 在当前指标下修改值 */
updatePostList(&L, 3, 20);
/* 批指标来获得值 */
printf("%d\n",GetElem(&L,3));
/* 从线性表L中删除头元素并返回它，若删除失败则停止程序运行 */
/* deleteFirstList(&L); */
/* 再删除表头 */
/* deleteFirstList(&L); */
/* traverseList(&L); */
/* 删除最后表头的值 */
/* deleteLastList(&L); */
/* deleteLastList(&L); */
/* 指定删除下标进行删除 */
printf("%d\n",deletePostList(&L,5));
printf("%d\n ", sizeList(&L));
printf("%d\n", EmptyList(&L));
traverseList(&L);
/* 清除线性列表 */
clearList(&L);
/* 清除了没有值了 */
traverseList(&L);
}
⑨ 数据结构线性表之线性表的顺序存储结构[1]
顺序表定义
顺序表 即用一组连续的存储单元依次存放线性表的数据元素 若每个数据元素占用c个存储单元 并以所占的第一个存储单元地址作为这个数据元素的存储位置 则表中任一元素ai的存储地址为 LOC(ai)=LOC(a )+(i )*c ≤i≤n
顺序表特点
为表中相邻的元素ai和ai+ 赋以相邻的存储位置LOC(ai)和LOC(ai+ )
顺序表的基本运算
顺序表的建立
由于程序语言中的向量（一组数组）就是采用顺序存储表示 故可用向量这种数组类型来描述顺序表 我们用结构类型来定义顺序表类型 如下 输入n个整数 产生一个存储这些整数的顺序表L的函数 如下
顺序表的查找
在一个顺序表中查找元素值为x的元素的函数 如下
顺序表的插入
线性表的插入运算是指在表的第i（ ≤i≤n）个位置上 插入一个新结点x 使长度为n的线性表（a … ai ai … an）变成长度为n+ 的线性表（a … ai ax ai … an） 插入操作分成两阶段 第一阶段将位于插入点以后的数据元素依次向后移动 为新数据元腾出一个空间 然后在第二阶段中将数据元素插入空挡 在一个顺序表中第i个元素之前插入一个元素x的函数 如下
lishixin/Article/program/sjjg/201311/23508
⑩ 【数据结构】求线性表的长度和线性表上的查找算法
/* 顺序存储类型*/
typedef struct
{ ElemType data[MAXSIZE]; /*存放线性表的数组*/
int length; /* length是顺序表的长度*/
}SqList; SqList L;
/* 求顺序表长度*/
int ListLength(SqList L)
{return(L.length);}
/* 给定序号从顺序表中查找元素*/
void ListGet(SqList L ,int i)
{ if(L.length==0) printf("顺序表空\n");
else if(i<1||i>L.length) printf("查找的位置不正确\n");
else printf("顺序表中第%d个元素的值为:%d\n",i,L.data[i-1]);
}
/* 从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/
int ListLocate(SqList L, ElemType x)
{int i=0;
while(i<L.length && L.data[i]!=x)
i++;
if (i<L.length) return (i+1);
else return 0;
}