输出线性表c语言

① 谁能给一个简单的线性表操作c语言完整程序

1、线性表有两种：

typedefstruct{

ElemType*elem;

intlength;

intlistsize;

}sqlist;//顺序表

voidInitList_Sq(SqList&l){

l.elem=newElemType[LIST_INIT_SIZE];

l.length=0;

l.listsize=LIST_INIT_SIZE;

}//初始化顺序表

然后SqListLa;

InitList_Sq(La);

就可以

typedefstructLnode{

intdata;

structLnode*next;

}Lnode,*LinkList;//线性链表

//单链表可以有效的利用主存的碎片,它的数据域不是连续的

2、例程：

#include"stdio.h"
#include<malloc.h>
typedefcharElemType;
typedefstructLNode
{ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListF(LinkList*&L,ElemTypea[],intn)//头插法建表
{
LinkList*s;inti;
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
voidCreateListR(LinkList*&L,ElemTypea[],intn)//尾插法建表
{
LinkList*s,*r;inti;
L=(LinkList*)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
voidInitList(LinkList*&L)//初始化线性表
{
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
}
voidDestroyList(LinkList*&L)//销毁线性表
{
LinkList*p=L,*q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
intListEmpty(LinkList*L)//判断线性表是否为空
{
return(L->next==NULL);
}
intListLength(LinkList*L)//求线性表的长度
{
LinkList*p=L;intn=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}
voidDispList(LinkList*L)//输出线性表
{
LinkList*p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}
intGetElem(LinkList*L,inti,ElemType&e)//求线性表中某个数据元素值
{
intj=0;
LinkList*p=L;
while(j<i&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
e=p->data;return1;
}
}
intLocateElem(LinkList*L,ElemTypee)//按元素值查找
{
LinkList*p=L->next;
inti=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
elsereturn(i);
}
intListInsert(LinkList*&L,inti,ElemTypee)//插入数据元素
{
intj=0;
LinkList*p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return0;
else
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=e;s->next=p->next;p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti,ElemType&e)//删除数据元素
{
intj=0;
LinkList*p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
q=p->next;
if(q==NULL)return0;
e=q->data;
p->next=q->next;
free(q);
return1;
}
}
intmain()
{
ElemTypee,a[5]={'a','b','c','d','e'};
LinkList*h;
InitList(h);//初始化顺序表h
CreateListR(h,&a[0],5);//依次采用尾插入法插入a，b，c，d，e元素
printf("单链表为：");
DispList(h);printf("
");//输出顺序表h
printf("该单链表的长度为：");
printf("%d",ListLength(h));printf("
");//输出顺序表h的长度
if(ListEmpty(h))printf("该单链表为空。
");
elseprintf("该单链表不为空。
");//判断顺序表h是否为空
GetElem(h,3,e);printf("该单链表的第3个元素为：");
printf("%c",e);printf("
");//输出顺序表h的第3个元素
printf("该单链表中a的位置为：");
printf("%d",LocateElem(h,'a'));printf("
");//输出元素'a'的位置
ListInsert(h,4,'f');//在第4个元素位置插入'f'素
printf("在第4个元素位置上插入'f'后单链表为：");
DispList(h);printf("
");//输出顺序表h
ListDelete(h,3,e);//删除L的第3个元素
printf("删除第3个元素后单链表为：");
DispList(h);printf("
");//输出顺序表h
DestroyList(h);//释放顺序表h
return0;
}

② C语言——线性表

#include"stdio.h"
#include<malloc.h>

typedef char ElemType;

typedef struct LNode
{ElemType data;
struct LNode *next;
}LinkList;

void CreatListF(LinkList *&L,ElemType a[],int n) //头插法建表
{
LinkList *s;int i;
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}

void CreateListR(LinkList *&L,ElemType a[],int n) //尾插法建表
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}

void InitList(LinkList *&L) //初始化线性表
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}

void DestroyList(LinkList *&L) //销毁线性表
{
LinkList *p=L,*q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}

int ListEmpty(LinkList *L) //判断线性表是否为空
{
return(L->next==NULL);
}

int ListLength(LinkList *L) //求线性表的长度
{
LinkList *p=L;int n=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}

void DispList(LinkList *L) //输出线性表
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}

int GetElem(LinkList *L,int i,ElemType &e) //求线性表中某个数据元素值
{
int j=0;
LinkList *p=L;
while(j<i&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return 0;
else
{
e=p->data;return 1;
}
}

int LocateElem(LinkList *L,ElemType e) //按元素值查找
{
LinkList *p=L->next;
int i=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
else return(i);
}

int ListInsert(LinkList *&L,int i,ElemType e) //插入数据元素
{
int j=0;
LinkList *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return 0;
else
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=e; s->next=p->next; p->next=s;
return 1;
}
}

int ListDelete(LinkList *&L,int i,ElemType &e) //删除数据元素
{
int j=0;
LinkList *p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return 0;
else
{
q=p->next;
if(q==NULL)return 0;
e=q->data;
p->next=q->next;
free(q);
return 1;
}
}

int main()
{
ElemType e,a[5]={'a','b','c','d','e'};
LinkList *h;

InitList(h); //初始化顺序表h
CreateListR(h,&a[0],5); //依次采用尾插入法插入a，b，c，d，e元素
printf("单链表为：");
DispList(h); printf("\n"); //输出顺序表h

printf("该单链表的长度为：");
printf("%d",ListLength(h)); printf("\n"); //输出顺序表h的长度
if(ListEmpty(h)) printf("该单链表为空。\n");
else printf("该单链表不为空。\n"); //判断顺序表h是否为空

GetElem(h,3,e);printf("该单链表的第3个元素为：");
printf("%c",e); printf("\n"); //输出顺序表h的第3个元素
printf("该单链表中a的位置为：");
printf("%d",LocateElem(h,'a')); printf("\n"); //输出元素'a'的位置

ListInsert(h,4,'f'); //在第4个元素位置插入'f'素
printf("在第4 个元素位置上插入'f'后单链表为：");
DispList(h); printf("\n"); //输出顺序表h

ListDelete(h,3,e); //删除L的第3个元素
printf("删除第3个元素后单链表为：");
DispList(h); printf("\n"); //输出顺序表h

DestroyList(h); //释放顺序表h
return 0;
}

③ C语言线性表急求大神解

#include<stdio.h>
#include<stdlib.h>

typedef struct
{
int *data,len;
}SL;

void showlist(SL *l)
{
int i;

for(i=0;i<(*l).len-1;i++)
{
printf("%d ",(*l).data[i]);
}
printf("%d\n",(*l).data[(*l).len-1]);
}

void createlist(SL *l)
{
int i,n;

printf("请输入线性表的长度：");
scanf("%d",&n);
(*l).len=n;
(*l).data=(int*)calloc(n,sizeof(int));
printf("请输入%d个整数：",n);
for(i=0;i<n;i++)
scanf("%d",(*l).data+i);
}

//找到，返回第1次出现的下标，
//找不到返回-1
int search(SL *l,const int n)
{
int i;

for(i=0;i<(*l).len;i++)
{
if(n==(*l).data[i])
return i;
}
return -1;
}

//n为要删除的整数的值，
//会删除所有值为n的线性表的元素
void delete(SL *l,const int n)
{
int i,j;

for(i=0;i<(*l).len;)
{
if(n==(*l).data[i])
{
for(j=i+1;j<(*l).len;j++)
{
(*l).data[j-1]=(*l).data[j];
}
(*l).len--;
}
else
i++;
}
}

void deleterange(SL *l,const int min,const int max)
{
int i;

for(i=0;i<(*l).len;i++)
{
if((*l).data[i]>=min && (*l).data[i]<=max)
delete(l,(*l).data[i]);
}
}

void freelist(SL *l)
{
if(!(*l).data)
free((*l).data);
}

int main()
{
int loc,tofind,min,max;
SL l;

createlist(&l);
printf("请输入要查找的整数：");
scanf("%d",&tofind);
if(-1!=(loc=search(&l,tofind)))
printf("此数据在线性表中第1次出现的下标是：%d\n",loc);
else
puts("线性表中无此数据");
printf("请输入要删除的整数的最小值 最大值：");
scanf("%d %d",&min,&max);
deleterange(&l,min,max);
printf("删除值为%d-%d的元素后的线性表如下：\n",min,max);
showlist(&l);
freelist(&l);
system("PAUSE");
return 0;
}

④ C语言线性表的问题

数据*la,*lb没有初始化，其他还有一点小问题，看代码

#include<stdio.h>
#include<stdlib.h>
#defineN100
#defineADD20

typedefstruct{
	int*data;
	intlength;
	intsize;
}sqlist;

intsqlist_est(sqlist*l){
	l->data=(int*)malloc(N*sizeof(int));
	l->length=0;
	l->size=N;
	return1;
}

voidsqlist_input(sqlist*l){
	inti,c,b;
	for(i=0;i<=l->size-1;i++){
		printf("pleaseinputthe%ddata:",i);
		scanf("%d",&c);
		if(b=getchar()=='
')break;
		else{
			l->data[i]=c;
			l->length++;
		}
	}
}


voidsqlist_sort(sqlist*l){
	intp,q,temp;
	for(p=0;p<l->length-1;p++)
		for(q=0;q<l->length-1-p;q++)
			if(l->data[q]>l->data[q+1]){
				temp=l->data[q];
				l->data[q]=l->data[q+1];
				l->data[q+1]=temp;
			}
}


intsqlist_insert(sqlist*l,intplace,intdat){
	int*news,i;
	if(l->length>=l->size){
		news=(int*)realloc(l->data,(l->size+ADD)*sizeof(int));
		l->data=news;
		l->size=l->size+ADD;
	}
	for(i=l->length-1;i>=place-1;i--)
		l->data[i+1]=l->data[i];
	l->data[place-1]=dat;
	l->length++;
	return1;
}


voidsqlist_del(sqlist*l,intdelplace){//函数类型错了
	inti;
	for(i=delplace-1;i<=l->length-1;i++)
		l->data[i]=l->data[i+1];
	l->length--;
}


intsqlist_merge(sqlist*la,sqlist*lb){
	inti,n,*news;
	n=la->length;
	if(la->length+lb->length>la->size){
		news=(int*)realloc(la->data,(la->size+la->size)*sizeof(int));
		la->data=news;
		la->size*=2;
	}
	for(i=0;i<=lb->length-1;i++){
		la->data[n]=lb->data[i];
		n++;
		la->length++;
	}
	return1;
}


voidsqlist_print(sqlist*l){
	inti;
	for(i=0;i<l->length-1;i++)
		printf("%d",l->data[i]);
}


voidmain(){
	intplace,delplace,dat,choose;
	sqlist*la=newsqlist,*lb=newsqlist;//初始化数据
	while(1){
		printf("1~创建线性表
");
		printf("2~向线性表中输入数据
");
		printf("3~将线性表中的数据进行排序
");
		printf("4~向线性表中插入一个数据
");
		printf("5~删除线性表中的一个数据
");
		printf("6~合并两个线性表
");
		printf("7~输出线性表
");
		printf("请输入你的选择：");
		scanf("%d",&choose);
		switch(choose)
		{case1:sqlist_est(la);break;
		case2:sqlist_input(la);break;
		case3:sqlist_sort(la);break;
		case4:{printf("请输入插入的位置数据：");
			scanf("%d%d",&place,&dat);
			sqlist_insert(la,place,dat);
			};break;
		case5:{printf("请输入要删除的位置：");
			scanf("%d",&delplace);//少了数据输入
			sqlist_del(la,delplace);
			};break;
		case6:{sqlist_est(lb);
			printf("现在请输入要合并的线性表的数值：");
			sqlist_input(lb);
			sqlist_merge(la,lb);
			};break;
		case7:sqlist_print(la);break;
		}
	}
}

⑤ C语言创建一个线性表，然后输出线性表，如何编写程序

#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>

#defineOVERFLOW -2
#define OK 1
#define ERROR 0
#defineLIST_INIT_SIZE 100
#defineLISTINCREMENT 10

typedef intElemType;
typedef intStatus;
//定义顺序存储结构
typedef struct
{
ElemType *elem;
int length;
int listsize;
}SqList;
//初始化顺序表
StatusInitList_Sq(SqList &L)
{
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem ) exit(ERROR);
L.length =0;
L.listsize =LIST_INIT_SIZE;
return OK;
}
//自定义创建顺序表
voidCreate_SqList(SqList &L)
{
int c,i=0;
int *newBase;
printf("请输入顺序表元素：\n");
while((scanf("%d",&c))!=EOF)
{
if(i>=L.listsize) //自定义顺序表大小超过初始化大小
{
newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
//为初始顺序表以LISTINCREMENT大小重新增加存储空间
if(!newBase)exit(OVERFLOW);
L.elem=newBase;
L.listsize+=LISTINCREMENT;
}
L.elem[i++]=c;
}
L.length=i;
printf("输入的顺序表元素：\n");
for(i=0;i<L.length;i++)
printf("%d ",L.elem[i]);
printf("\n");
}
//在指定位置插入元素
StatusListInsert(SqList &L,int i,ElemType e)
{
ElemType *p,*q,*newbase;
if(i<1||i>L.length+1)
{
printf("插入位置错误\n");
return(ERROR);
}
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;
}
if(i==L.length) L.elem[i+1]=e;
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
//在指定位置删除元素
StatusListDelete_Sq(SqList &L,int i,ElemType *e)
{
ElemType *p,*q;
if(i<1||i>L.length+1)
return ERROR;
p=&(L.elem[i-1]);
*e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.length ;
return OK;
}

void main()
{
SqList L;
int m,n;
int location,element;
if(!InitList_Sq(L))
{
printf("初始化顺序表失败！\n");
exit(ERROR);
}
Create_SqList(L);
for(m=0;m<3;m++)
{
printf("输入插入位置：");
scanf("%d",&location);
while(location>L.length+1||location<1)
{
printf("输入位置错误，请重新输入！\n");
scanf("%d",&location);
}
printf("插入元素：");
scanf("%d",&element);
if(!ListInsert(L,location,element))
{
printf("顺序表插入失败！\n");
exit(ERROR);
}
printf("插入顺序表为：\n");
for(int i=0;i<=L.length -1;i++)
{
printf("%d ",L.elem[i]);
}
printf("\n新顺序表一共有%d个元素。\n",L.length);
}
for(n=0;n<3;n++)
{
printf("输入删除位置：");
scanf("%d",&location);
while(location>L.length||location<1)
{
printf("输入位置错误，请重新输入！\n");
scanf("%d",&location);
}
if(!ListDelete_Sq(L,location,&element))
{
printf("删除错误！\n");
exit(ERROR);
}
printf("被删除的元素为：%d \n",element);

printf("被删除后的顺序表为：\n");
for(int j=0;j<=L.length-1;j++)
{
printf("%d ",L.elem[j]);
}
printf("\n新顺序表一共有%d个元素。\n",L.length);
}
}
这个是我最近编写的 顺序表也是线性表的
这里还有链表的程序 用的话再传给你

⑥ 如何用C语言写一个函数输出线性表中指定范围的数字

#include<stdio.h>

intmain(void)
{
intdata[]={2,5,15,30,1,40,17,50,9,21,32,8,41,22,49,31,33,18,50,5};
intnewdata[30];
inti,j=0;
for(i=0;i<sizeof(data);i++)
{
if(data[i]>=10&&data[i]<=30)
{
continue;
}
else
{
newdata[j]=data[i];
j++;
}
}
for(i=0;i<j;i++)
{
printf("%d",newdata[i]);
}
getchar();
return0;
}

这个代码里面的 data[]后面赋值你就输入你的线性表 的数，代码会自己查找并删除。

data[i]>=10&&data[i]<=30

这句话就是范围意思是 大于10小于30的数，删除后的数组会存在newdata数组里面

请采纳！

⑦ C语言创建一个线性表，然后输出线性表，如何编写程序

#include #include #include #defineOVERFLOW-2 #defineOK1 #defineERROR0 #defineLIST_INIT_SIZE100 #defineLISTINCREMENT10 typedefintElemType; typedefintStatus; //定义顺序存储结构 typedefstruct { ElemType*elem; intlength; intlistsize; }SqList; //初始化顺序表 StatusInitList_Sq(SqList&L) { L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!L.elem)exit(ERROR); L.length=0; L.listsize=LIST_INIT_SIZE; returnOK; } //自定义创建顺序表 voidCreate_SqList(SqList&L) { intc,i=0; int*newBase; printf("请输入顺序表元素：\n"); while((scanf("%d",&c))!=EOF) { if(i>=L.listsize)//自定义顺序表大小超过初始化大小 { newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType)); //为初始顺序表以LISTINCREMENT大小重新增加存储空间 if(!newBase)exit(OVERFLOW); L.elem=newBase; L.listsize+=LISTINCREMENT; } L.elem[i++]=c; } L.length=i; printf("输入的顺序表元素：\n"); for(i=0;iL.length+1) { printf("插入位置错误\n"); return(ERROR); } 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; } if(i==L.length)L.elem[i+1]=e; q=&(L.elem[i-1]); for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p; *q=e; ++L.length; returnOK; } //在指定位置删除元素 StatusListDelete_Sq(SqList&L,inti,ElemType*e) { ElemType*p,*q; if(i<1||i>L.length+1) returnERROR; p=&(L.elem[i-1]); *e=*p; q=L.elem+L.length-1; for(++p;p<=q;++p) *(p-1)=*p; --L.length; returnOK; } voidmain() { SqListL; intm,n; intlocation,element; if(!InitList_Sq(L)) { printf("初始化顺序表失败！\n"); exit(ERROR); } Create_SqList(L); for(m=0;m<3;m++) { printf("输入插入位置："); scanf("%d",&location); while(location>L.length+1||location<1) { printf("输入位置错误，请重新输入！\n"); scanf("%d",&location); } printf("插入元素："); scanf("%d",&element); if(!ListInsert(L,location,element)) { printf("顺序表插入失败！\n"); exit(ERROR); } printf("插入顺序表为：\n"); for(inti=0;i<=L.length-1;i++) { printf("%d",L.elem[i]); } printf("\n新顺序表一共有%d个元素。\n",L.length); } for(n=0;n<3;n++) { printf("输入删除位置："); scanf("%d",&location); while(location>L.length||location<1) { printf("输入位置错误，请重新输入！\n"); scanf("%d",&location); } if(!ListDelete_Sq(L,location,&element)) { printf("删除错误！\n"); exit(ERROR); } printf("被删除的元素为：%d\n",element); printf("被删除后的顺序表为：\n"); for(intj=0;j<=L.length-1;j++) { printf("%d",L.elem[j]); } printf("\n新顺序表一共有%d个元素。\n",L.length); } } 这个是我最近编写的顺序表也是线性表的 这里还有链表的程序用的话再传给你

⑧ 用c语言编写程序1.建立一个线性表，输入n个元素并输出2.查找最大元素并输出

线性表 可以使用链表 或者数组实现

以动态数组为例

#include<stdio.h>
#include<stdlib.h>
intmain()
{
int*a,n,max,i;
scanf("%d",&n);
a=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
scanf("%d",a+i);
for(i=1,max=a[0];i<n;i++)
if(max<a[i])max=a[i];
printf("%d
",max);
free(a);
return0;
}

⑨ c语言线性表的插入和输出功能实现的代码

#include"stdio.h"
#include"malloc.h"
#include"iostream.h"
typedef int elementype;
typedef struct link
{
elementype data;
struct link *next;
}link,*linklist;
int initlink(linklist l)
{
linklist p,q;
int n;
p=(link*)malloc(sizeof(linklist));
p=l;
while(1){
q=(linklist)malloc(sizeof(link));
printf("请输入链表数据:");
scanf("%d",&n);
if(n==0) break;
q->data=n;
p->next=q;
p=q;

}

p->next=NULL;
return 1;
}
int insertlink(linklist l)
{
int a,b,j=0;
linklist p,s;
p=l;
printf("请输入你要插入的位置:");
scanf("%d",&a);
printf("请输入你要插入的数据:");
scanf("%d",&b);
while(p->next!=NULL&&j+1<a)
{
p=p->next;
j++;
}
s=(linklist )malloc(sizeof(linklist));
s->data=b;
s->next=p->next;

p->next=s;
return 1;

}
int printflink(linklist l)
{
linklist p;
p=l->next;
while(p!=NULL)
{
printf("%d\t",p->data);
p=p->next;
}
printf("\n");
return 1;
}
int main()
{
linklist l;
int a;
l=(linklist)malloc(sizeof(linklist));

l->next=NULL;
initlink(l);
printflink(l);
insertlink(l);
printflink(l);

return 1;
}

⑩ 线性表的基本操作c语言实现

代码如下：

头文件：

2_1.h

#ifndef _2_1_H

#define _2_1_H

typedef void SeqList;

typedef void SeqListNode;

//创建线性表

SeqList * SeqList_Create(int capacity);

//销毁线性表

void SeqList_DesTroy(SeqList * list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

源文件：

// 顺序线性表.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <malloc.h>

#include <stdlib.h>

#include "2_1.h"

typedef unsigned int TSeqListNode;

typedef struct {

int len; //长度

int capacity;//总长度

TSeqListNode * node;//每个节点的指针

} TSeqList;

int main()

{

SeqList* list = SeqList_Create(5);//创建线性表

int i = 6;//赋值6个变量，已超过线性表最大值 5

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 0;

SeqList_Insert(list, &i, 7); //将这6个变量插入线性表中

SeqList_Insert(list, &j, 0);

SeqList_Insert(list, &k, 0);

SeqList_Insert(list, &x, 0);

SeqList_Insert(list, &y, 0);

SeqList_Insert(list, &z, 0);

//遍历

for(index=0; index<SeqList_Length(list); index++)

{

int* p = (int*)SeqList_Get(list, index);

printf("%d ", *p);

}

printf(" ");

//删除操作

while( SeqList_Length(list) > 0 )

{

int* p = (int*)SeqList_Delete(list, 0);

printf("删除了： %d ", *p);

}

SeqList_Clear(list);

SeqList_DesTroy(list);

system("pause");

return 0;

}

//创建线性表

SeqList * SeqList_Create(int capacity)

{

TSeqList* ret = NULL ;

if(capacity >= 0)

{

ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //为线性表分配空间，包含结 //构体和节点的总大小

}

if(NULL != ret)

{

ret->len = 0;

ret->capacity = capacity;

ret->node = (TSeqListNode*)(ret + 1);//将节点指向上述分配到的空间的后部分

}

return ret;

}

//销毁

void SeqList_DesTroy(SeqList * list)

{

free(list);

}

//清空

void SeqList_Clear(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

if(NULL != ret)

{

ret->len = 0;

}

}

//获得线性表的长度

int SeqList_Length(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int len = -1;

if(NULL != ret)

{

len = ret->len;

}

return len;

}

//线性表的总长度

int SeqList_Capacity(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int capacity = -1;

if(NULL != ret)

{

ret->capacity = capacity;

}

return capacity;

}

//插入

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)

{

TSeqList * sList = (TSeqList*)list;

int i,ret = -1;

if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)

{

if(pos >= sList->len)

{

pos = sList->len;

}

for(i = sList->len; i > pos; i--)

{

sList->node[i] = sList->node[i-1];

}

sList->node[i] = (TSeqListNode)node;

++sList->len;

ret = 1;

}

return ret;

}

//获得指定位置的节点

SeqListNode* SeqList_Get(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

TSeqListNode* node = NULL;

if(NULL != sList && pos>=0 && pos < sList->len)

{

node = (TSeqListNode*)sList->node[pos];

}

return node;

}

//删除

SeqListNode* SeqList_Delete(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

SeqListNode * node = SeqList_Get( list, pos);

int i;

if(sList != NULL && pos >= 0 && pos< sList->len)

{

for( i=pos+1; i<sList->len; i++)

{

sList->node[i-1] = sList->node[i];

}

sList->len--;

}

return node;

}

演示：

资料拓展：

线性表是最基本、最简单、也是最常用的一种数据结构。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。

在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的操作受限制。

线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。