c语言线性表基本操作

㈠ 线性表的操作（c语言）

//---------------------------------------------------------------------------

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

#define STY "%d"/*元素类型格式符*/
typedef int eltp;/*元素类型*/

typedef struct node{
eltp data;
struct node *next;
} node;

void init(void)
{
static int fg=1;
if (fg) {
srand(time(NULL));
fg=0;
}
}
node *insert(node *h,eltp d)
{
node *s=(node *)malloc(sizeof(node));
if (!h) {
s->data=d;
s->next=NULL;
h=s;
}
else {
h->next=insert(h->next,d);
}
return h;
}
node *create(int n)
{
node *h=NULL;
int i;
for (i = 0; i<n; i++) {
h=insert(h,rand()%100);
}
if (h) {
printf("线性表生成已完成!\n");
}
else {
fprintf(stderr,"线性表生成未成功\n");
exit(-1);
}
return h;
}
node *del(node *h,eltp d)
{
node *p;
if (h&&h->data==d) {
p=h;
h=h->next;
free(p);
}
else if (h) h->next=del(h->next,d);

return h;
}
int search(node *h,eltp d)
{
int i=1;
while (h&&h->data!=d)
{
h=h->next;
i++;
}
if (!h) i=-1;
return i;
}

int count(node *h)
{
int i=0;
for (i = 0; h; i++) {
h=h->next;
}
return i;
}

void prt(node *h)
{
while (h)
{
printf(STY"\t",h->data);
h=h->next;
}
putchar('\n');
}
void Free(node **h)
{
if (*h) {
Free(&(*h)->next);
free(*h);
*h=NULL;
}
}
int menu(void)
{
int i;
puts("******************");
puts("1.生成线性表");
puts("2.输出表元素");
puts("3.删除表元素");
puts("4.查找表元素");
puts("5.统计表元素");
puts("6.插入表元素");
puts("7.删除线性表");
puts("0.退出本程序");
puts("******************");
printf("请选择:");
scanf("%d",&i);
return i;
}
void find(node *h)
{
eltp a;
//node *t=NULL;
int index;
printf("请输入要查找的数字:");
scanf(STY,&a);
index=search(h,a);
if (index!=-1) {
printf(STY"是表中的第%d个元素\n",a,index);
}
else printf(STY"不是表中的元素\n",a);
}
node *insert_node(node *h,int index,eltp a)
{
node *hd=h,*in=(node *)malloc(sizeof(node));
int i;
in->data=a;
if (index>1) {
for (i=1; h->next&&i<index-1; i++) {
h=h->next;
}
in->next=h->next;
h->next=in;
}
else {
in->next=hd;
hd=in;
}
return hd;
}
node *remove_node(node *h)
{
eltp a;
printf("请输入要删除的元素:");
scanf(STY,&a);
h=del(h,a);
puts("已完成");
return h;
}
node *ins(node *h)
{
eltp a;
int i;
printf("请输入要插入的元素:");
scanf(STY,&a);
printf("请输入要插入的位置:");
scanf("%d",&i);
return insert_node(h,i,a);
}
int main(void)
{
node *head=NULL;
int ch;
init();
do
{
ch=menu();
switch (ch) {

default:printf("输入有误，重新输入\n");break;
case 0:break;
case 1:if(head) Free(&head);
head=create(10);
break;
case 2:prt(head);break;
case 3:head=remove_node(head);break;
case 4:find(head);break;
case 5:printf("表中共有%d个元素\n",count(head));break;
case 6:head=ins(head);break;
case 7:Free(&head);break;

}
}while (ch);
Free(&head);
return 0;
}
//---------------------------------------------------------------------------

㈡ 线性表的基本操作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语言完整程序

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语言数据结构线性表单链表的基本操作，写好了代码，编译没有错但运行有错，求找错误在哪谢谢 #in

VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

㈤ C语言线性表基本操作求助

#include<stdio.h>
#include<stdlib.h>
# define MAXSIZE 100
# define OK 1
# define ERROR 0
typedef int ElemType;
typedef struct
{
ElemType data[MAXSIZE];
int length;
}Sqlist;
int CreateList(Sqlist *L)//创建线性表
{
int i, n, num;
printf("请输入元素个数：");
scanf("%d", &n);
printf("请依次输入整数值：");
for (i = 1; i <=n; i++)//一共n个元素,=号
{
scanf("%d", &num);
L->data[i] = num;
L->length++;//长度加1
}
return OK;
}

int ListLength(Sqlist* L)//返回线性表长度
{
printf("线性表的长度为：%d", L->length);
return L->length;
}

int PrintList(Sqlist* L)//依次输出线性表
{
int i;
for (i = 1; i <= L->length; i++)
{
printf("%d\t", L->data[i]);
}
printf("\n");
return OK;
}

int InsertList(Sqlist *L, int i, ElemType e)//插入元素s
{
int k;
if (L->length == MAXSIZE )
return ERROR;
if (i<1 || i>L->length +1 )
return ERROR;
if (i <= L->length)
{
for (k = L->length; k >= i - 1; k--)//k--，下标从1开始则lengh位置已有元素，不应length-1
L->data[k + 1] = L->data[k];
}
L->data[i] = e;//i不减1
L->length++;
return OK;
}

int DeletList(Sqlist *L, int i)//删除元素
{
int k;
if (L->length == 0)//==
return ERROR;
if (i<1 || i>L->length)
return ERROR;
if (i <= L->length)
{
for (k = i; k < L->length; k++)
L->data[k] = L->data[k+1];//应该这样
}
L->length--;
return OK;

}

int GetElem(Sqlist* L, int i, ElemType* e)//用e返回线性表中第i个元素的值
{
if (L->length ==0 || i<1 || i>L->length)//==
return ERROR;
*e = L->data[i];//前面下标都是1开始，就不用-1了
return OK;
}

int MergeList(Sqlist* L1, Sqlist* L2, Sqlist *L3)//两个线性表求并集，结果放在L3里
{
int i, j, k;
i = 1;
j = 1;
k = 1;
while ((i <= L1->length) && (j <= L2->length))
{
if (L1->data[i] == L2->data[j])
{
L3->data[k] = L1->data[i];
i++;
j++;
}
else
if (L1->data[i] < L2->data[j])
{
L3->data[k] = L1->data[i];
i++;
}
else
{
L3->data[k] = L2->data[j];
j++;
}
k++;
}
if (i > L1->length)
for (i = j; i <= L2->length; i++)
{
L3->data[k] = L2->data[i];
k++;
}
else
for (j = i; j <= L1->length; j++)
{
L3->data[k] = L1->data[j];
k++;
}
L3->length = k - 1;
return OK;
}
void menu()
{
printf("\n");
printf(" *******************顺序线性表功能菜单*******************\n");
printf(" * 1：建立线性表 2：插入元素 *\n");
printf(" * 3: 删除元素 4：合并线性表 *\n");
printf(" * 5：打印线性表 6：查找特定元素 *\n");
printf(" * 7：线性表长度 8：退出 *\n");
printf(" ********************************************************\n");
printf(" 请输入你的选择：");
}
void main()
{
Sqlist L, L1, L2, L3;
ElemType e;
int i,n,flag;
char a;
L.length = 0;
//int CreateList(Sqlist *L);//函数原型
//int ListLength(Sqlist* L);
//int PrintList(Sqlist* L);
//int InsertList(Sqlist *L, int i, ElemType e);
//int DeletList(Sqlist *L, int i);
//int GetElem(Sqlist* L, int i, ElemType e);
//int MergeList(Sqlist L1, Sqlist L2, Sqlist *L3);
menu();
do
{
scanf("%d",&n);
if(n>=1&&n<=7)
{
flag=1;
break;
}
else
{
flag=0;
printf("您输入有误，请重新选择!");
}
}
while(flag==0);
while(flag==1)
{
switch (n)
{
case 1:
CreateList(&L);
PrintList(&L);
break;
case 2:
printf(" 请输入要插入的数据元素：");
scanf("%d", &e);
printf(" 请输入要插入的元素位置：");
scanf("%d", &i);
InsertList(&L, i, e);
break;
case 3:
printf(" 请输入要删除的元素位置：");
scanf("%d", &i);
DeletList(&L, i);
PrintList(&L);
break;
case 4:
printf(" 创建第一个顺序表");
CreateList(&L1);
printf(" 创建第二个顺序表");
CreateList(&L2);
PrintList(&L1);
PrintList(&L2);
MergeList(&L1, &L2, &L3);
PrintList(&L3);
break;
case 5:
PrintList(&L);break;//这里开始都忘了break
case 6:
printf("请输入查看元素序号：");
scanf("%d", &i);
GetElem(&L, i, &e);
printf("第%d个元素为%d", i, e);break;
case 7:
ListLength(&L);break;
case 8:
exit(0);
break;
default:
break;
}
getchar();
printf("\n");
printf("是否继续进行(y or n):\n");
scanf("%c",&a);
if(a=='y')
{
flag=1;
system("cls"); /*清屏*/
menu(); /*调用菜单函数*/
printf("请再次选择你需要操作的步骤(1--7):\n");
scanf("%d",&n);
printf("\n");
}

else
exit(0);

}
}

㈥ 实现线性表或栈或队列（三选一）的基本操作（用C语言实现）

楼上的两个代码都可以用，一个是顺序表，一个是链表

㈦ 线性表的操作，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语言建立一个顺序存储的线性表并实现线性表的插入和删除操作

链表
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语言版）线性表的操作

//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int *elem;
int length;
int listsize;
}sqlist;
void initlist_sq(sqlist *L){ /*注意这里*/
L->elem=(int *)malloc(5*sizeof(sqlist)); /*注意这里*/
if(!L->elem) /*注意这里*/
exit(0);
L->length=0; /*注意这里*/
L->listsize=5; /*注意这里*/
}
int main()
{
int i;
sqlist p;
initlist_sq(&p); /*注意这里*/
for(i=0;i<5;i++)
{
printf("%d ",i);
scanf("%d",&p.elem[i]);
p.listsize++;
}
printf("%d\n",p.listsize);
for(i=0;i<5;i++)
{
printf("%d\n",p.elem[i]);
p.listsize--;
}
printf("%d",p.listsize);

}
//---------------------------------------------------------------------------

㈩ 怎样创建线性表（C语言）

线性表是个抽象的概念，没办法直接创建抽象类型，需要具体的类型（比如数组，链表）。
比如创建数组：int array[100];
创建一个GList链表: GList * list = NULL; (空的）