c语言线性表顺序表

‘壹’ 用c语言建立一个顺序存储的线性表并实现线性表的插入和删除操作

链表
1。是由结构体和指针构成的。
2。包括两个部分一个是数据域和指针域。
3。链表中的结点分为两类：头结点和一般结点。头结点是没有数据域的。
4。基本操作有：初始化链表，增加结点和删除结点，求链表的长度等等。
struct Linknode{
int data;
struct Linknode *next;
};
这个地方有个知识点：这个是链表的数据结构是有结构体和指针构成。结构体名为Linknode.但这里面没有定义结构体变量，只有我们定义了结构体变量才能使用结构体。
结构体变量怎么定义呢？
有两种方式：
1。struct Linknode Linklist;
2.typedef struct linknode Linklist.
一般我们都希望采用第2种，这样的好处是: 当我们再定义结构体变量时，可以用：Linklist p;而如果我们采用第一种还必须采用 struct Linknode p;对比一下就可以知道第2种要简单很多。那么下面我们都采用第2种方式来定义结构体变量。
上面我们已经定义了一个链表：
1。初始化链表。
#include
#include
int InitLinkList(Linklist **Lnode)
{
*Lnode=(Linklist)malloc(sizeof(Linklist));//*Lnode等于L，对与*Lnode的分配空间相当与对主函数中的L分配空间。
if(!*Lnode)
return 0;
（*Lnode）->next=NULL;
}
在初始化链表的时候，我们用到了2级指针为什么呢？因为我们希望在InitLinkList函数生成的头结点，主函数中也能指向这个头结点。如果我们用一级指针的话，用malloc分配空间的时候，它将会返回分配空间的首地址给指针变量Lnode，而不能使是的空间被主函数中指针变量L得到这个地址。所以我们要用2级指针。
void main()
{
Linklist *L;
InitLikList(&L);
}
2。增加链表结点
增加链表结点其实很简单，一般用到三个结构体指针变量和一个循环结构。
InsertLinkList(Linklist *Lnode)
{
Linklist *p,*q;
int d;
{
scanf("%d",&d);
if(d==-9999)
break;
p=Lnode->next;//p指向头结点
//通过while循环和指针变量p定位要插入的结点q的位置。
while（p）
p=p->next;
//生成一个要插入的结点
q=(Linklist)malloc(sizeof(Linklist));//申请要插入的结点空间
q->data=d;//填充要插入结点的数据域
q->next=p->next;//首先填充要插入结点q的指针域进行填充。
p->next=q;//然后把定位好的p指针域进行修改指向q.

}while(9);//循环退出的条件是输入的数据-9999

}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入结点
}
3。求链表的长度：
int LengthLinkList(Linklist *Lnode)
{
int i=0;
Linklist *p;
p=Lnode->next;//p指向链表的第一个结点。
while(p)
{
i++;
p=p->next;
}
return i;
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入一个结点
LengthLinkList(L)//求链表的长度。
}
4.删除结点
删除链表结点其实很简单，一般用到三个结构体指针变量和一个循环结构。
DestroyLinkList(Linklist *Lnode)
{
Linklist *p,*q;
p=Lnode;//p指向链表的头结点
while(p)
{
q=p->next;//q指向当前结点的下一个结点。
free(p);//释放当前结点
p=q;//p指向下一个结点
}
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一个头结点
InsertLinkList(L);//插入结点
LengthLinkList(L)//求链表的长度。
DestroyLinkList(L);//删除链表结点
}

‘贰’ 是C语言中建立顺序表的程序

C语言中建立顺序表的操作顺序如下：

1.清空顺序表：其实清空只不过将元素长度置0，让后面插入数据函数的长度从0开始，其实并不是真正清空，之前的数据元素在内存中还存在，只不过可以被新元素覆盖而已。

2.判断顺序表是否为空

‘叁’ 数据结构实验（C语言）： 顺序表实验

//线性表函数操作
#include <stdio.h>
#include <string.h>

#define MaxSize 30
#define Error 0
#define True 1

typedef char ElemType;

typedef struct
{
ElemType elem[MaxSize];

int length;
}sqlist; /*顺序表类型定义*/

void InitList(SqList * &L) /*初始化顺序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L -> length = 0;
}

void DestroyList( SqList *L ) /*释放顺序表L*/
{
free(L);
}

int ListEmpty( SqList *L ) /*判断顺序表L是否为空表*/
{
return( L -> length == 0);
}

int ListLength( SqList *L ) /*返回顺序表L的元素个数*/
{
return( L -> length);
}

void DispList( SqList *L ) /*输出顺序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i < L -> length; i++ )
printf("%c", L -> elem[i]);
printf("\n");
}

int GetElem( SqList *L, int i, ElemType &e) /*获取顺序表中的第i个元素*/
{
if( i < 1 || i > L -> elem[i])
return Error;
e = L -> elem[i - 1];
return True;
}

int LocateElem( SqList *L, ElemType e) /*在顺序表中查找元素e*/
{
int i = 0;
while( i < L -> length && L -> elem[i] != e)
i++;
if(i >= L -> length)
return Error;
else
return i+1;
}

int ListInsert( SqList * &L, int i, ElemType e) /*在顺序表L中第i个位置插入元素e*/
{
int j;
if( i < 1 || i > L -> length + 1)
return 0;
i--; /*将顺序表位序转化为elem下标*/
for( j = L -> length; j > i; j--) /*将elem[i]及后面元素后移一个位置*/
L -> elem[j] = L -> elem[j - 1];
L -> elem[i] = e;
L -> length++; /*顺序表长度增1*/
return True;
}

int ListDelete( SqList * &L, int i, ElemType &e) /*顺序表L中删除第i个元素*/
{
int j;
if( i < 1 || i > L -> length)
return Error;
i--; /*将顺序表位序转化为elem下标*/
e = L -> elem[i];
for(j = i; j < L -> length - i; j++)
L -> elem[j] = L -> elem[j + 1];
L -> length--; /*顺序表长度减1*/
return True;
}

void main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L\n");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度 = %d\n", ListLength(L));
printf("(5)顺序表L为%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)顺序表L的第3个元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)输出新的顺序表L:");
DispList(L);
printf("(10)删除L的第3个元素\n");
ListDelete(L, 3, e);
printf("(11)输出新的顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);

}

‘肆’ 用C语言建立一个顺序存储的线性表并实现线性表的插入和删除操作

此顺序表实现了多个功能，代码很完善，我将其改成从键盘输入跟选择删除了，你根据你的需要自己再进行修改。

//common.h文件，头文件
#ifndef_COMMON_H_
#define_COMMON_H_

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

#defineTRUE1
#defineFALSE0

#defineMAXSIZE100

typedefintdatatype;

typedefstruct
{
	datatypedata[MAXSIZE];
	intlength;
}sqnode,*sqlink;

voidcreat_sqlist(sqlink*sq);
voidset_empty_sqlist(sqlinksq);
intisempty_sqlist(sqlinksq);
intisfull_sqlist(sqlinksq);
intgetlength_sqlist(sqlinksq);
datatypegetelem(sqlinksq,inti);//i为第i个元素
intlocate_sqlist(sqlinksq,datatypex);//返回该元素在表中的位置
voidinsert_sqlist(sqlinksq,datatypex,inti);//表示在表中第i个位置前插入。
datatypedel_sqlist(sqlinksq,inti);//删除表中第i个元素
voidshow_sqlist(sqlinksq);

#endif

//线性表实现的c代码
#include"common.h"
voidcreat_sqlist(sqlink*sq)
{
	*sq=(sqlink)malloc(sizeof(sqnode));
	assert(*sq);
	bzero(*sq,sizeof(sqnode));
	(*sq)->length=0;
}

voidset_empty_sqlist(sqlinksq)
{
	sq->length=0;
}

intisempty_sqlist(sqlinksq)
{
	returnsq->length==0?TRUE:FALSE;
}

intisfull_sqlist(sqlinksq)
{
	returnsq->length==MAXSIZE?TRUE:FALSE;
}

intgetlength_sqlist(sqlinksq)
{
	returnsq->length;
}

datatypegetelem(sqlinksq,inti)//i为第i个元素
{
	if(i<1||i>getlength_sqlist(sq))
	{
		printf("iiswrong!
");
		returnFALSE;
	}
	returnsq->data[i-1];
}

intlocate_sqlist(sqlinksq,datatypex)//返回该元素在表中的枯耐位置
{
	intj=1;
	while(j<=getlength_sqlist(sq))
	{
		if(sq->data[j-1]==x)
			returnj;
		j++;
	}
	returnFALSE;
}
voidinsert_sqlist(sqlinksq,datatypex,inti)//表示在表中第i个没和春位置前插入。
{
	intj=1;
	if(isfull_sqlist(sq))
	{
		printf("sqlistisfull!
");
		return;
	}
	if(i<1||i>getlength_sqlist(sq)+1)
	{
		printf("iisnotintherange!
");
		return;
	}
	for(j=getlength_sqlist(sq)-1;j>=i-1;j--)
	{
		sq->data[j+1]=sq->data[j];
	}
	sq->data[i-1]=x;
	++sq->length;
}
datatypedel_sqlist(sqlinksq,inti)//删除表中第i个元素
{
	datatyperet;
	if(isempty_sqlist(sq))
	{
		printf("sqlistisempty!
");
		returnFALSE;
	}
	if(i<1||棚兆i>getlength_sqlist(sq))
	{
		printf("iisnotintherange!");
		returnFALSE;
	}
	for(i;i<getlength_sqlist(sq);i++)
		sq->data[i-1]=sq->data[i];
	--sq->length;
	returnret;
}

voidshow_sqlist(sqlinksq)
{
	intj=0;
	for(j;j<getlength_sqlist(sq);j++)
		printf("%d,",sq->data[j]);
	putchar('
');
}
//main函数
#include"common.h"

intmain(intargc,char*argv[])
{
	inti=0,n,id;
	intnum;
	printf("你要往顺序表中插入几个元素
");
	scanf("%d",&num);
	printf("请往顺序表中插入%d个元素：
",num);
	sqlinksq=NULL;
	creat_sqlist(&sq);
	while(i<num)
	{
	scanf("%d",&n);
		insert_sqlist(sq,n,1);
		i++;
	}
	printf("顺序表的存储如下：
");
	show_sqlist(sq);
	printf("你要删除第几个元素?
");
	scanf("%d",&id);
	del_sqlist(sq,id);
	printf("删除第%d个元素之后的顺序表为：
",id);
	show_sqlist(sq);
	return0;
}

‘伍’ 线性表的基本操作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;

}

演示：

资料拓展：

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

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

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

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

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

‘陆’ 利用c语言实现顺序存储线性表的插入!

有时会出现这种情况。他会以为是木马。
int GetElem();
int InstInsert();
typedef int ElemType;
typedef struct{
ElemType *elem; //存储空间基地址
int length; //当前长度
int listsize;//当前分配的存储容量
}SqList;
int InitList(SqList *L){
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)exit(-1);//存储空间分配失败
L->length=0; //空表长度为0
L->listsize=LIST_INIT_SIZE; //初始存储容量
printf("线性链表创建成功\n");
return OK;
}
int Input(SqList *L){
ElemType temp,*newbase;
printf("输入顺序列表的数据，以0为结束标志\n");
scanf("%d",&temp);
while(temp!=0){
if(L->length>=L->listsize){
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!newbase) exit(-1);//存储空间分配失败
L->elem=newbase; //空间新基地址
L->listsize+=LISTINCREMENT; //增加存储容量
}
L->elem[L->length++]=temp;
scanf("%d",&temp);
}
printf("输入数据结束！！\n");
return OK;
}
int Onput(SqList *L){
int i=0;
printf("输出线性表数据：");
while(i<L->length){
printf("%d\t",L->elem[i]);
i++;
}
printf("\n");
}
int ClearList(SqList *L){
L->length=0;
printf("清除成功!\n");
return OK;
}
void ListEmpty(SqList L){
if(L.elem!=NULL)
printf("true!\n");
else
printf("false!\n");
}
void ListLength(SqList L){
printf("线性表的长度是：%d\n",L.length);
return ;
}
int GetElem(SqList L,int i,SqList *e){
e=L.elem[i-1];
return e;
}
void PriorElem(SqList L,int cur_e,SqList *pre_e){
if(cur_e!=L.elem[0]){
pre_e=L.elem[0];
printf("前驱值为：%d\n",pre_e);
}
else
printf("pre_e无意义\n");
}
void NextElem(SqList L,int cur_e,SqList *next_e){
if(cur_e!=L.elem[L.length-1]){
next_e=L.elem[L.length-1];
printf("后继值为：%d\n",next_e);
}
else
printf("next_e无意义\n");
}
int ListInsert(SqList *L,int i,int e){
ElemType *newbase,*p,*q;
if(1>i||i>(L->length+1))
return -1;
if(L->length>=L->listsize){ //新增内存
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); //开辟新内存空间
if(!newbase)
exit(-1); //存储分配失败
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 OK;
}
int ListDelete(SqList *L,int i,int e){
ElemType *p,*q;
if(i<1||i>L->length)
return -1;
q=&(L->elem[i-1]);
e=L->elem[i-1];
p=L->elem+L->length-1;
for(;p>=q;q++)
*q=*(q+1);
--L->length;
printf("删除的值为：%d\n",e);
return OK;
}

‘柒’ 用c语言描述顺序存储结构的线性表求表长的算法

#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,这样避免了再写函数求表长