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,這樣避免了再寫函數求表長