数据结构c语言版单链表的基本操作

❶ c语言数据结构单链表（头插入法）

head=(LNode
*)malloc(sizeof(LNode));
这一句不要，没啥用处，除非你head指向的节点也就是第一个节点的data不需要数据
head->next=NULL;这里修改为head=NULL;
让head先指向NULL，也就是没有节点
其实这个可以不要，再主函数中，先让链表是空链表即可（即让head=NULL）
head->data=data;
head->next=p->next;
head->next=p;
关键在这里
你仔细考虑一下，一般来说头插法的head只是一个指针，不要对head指向的那个节点操作，对p操作完成后，让head指过去即可
所以修改为
p->data=data;
//赋值过去，因为你现在申请了p的内存空间
p->next=head;
//把head指向的那个节点连接到p的后面，这样完成头插
//
这是head没有用了，p成为链表的头指针
head=p;
//head再指向这个链表的头部，也就是p指向的节点，为下一次循环做准备
head=Createlist(head);//链表初始化
主函数中这样不太好，建议不要重名

❷ 数据结构单链表用c语言如何实现

# include<stdio.h>
# include<stdlib.h>
typedef int datatype;
typedef struct node{
datatype data;
struct node *next;
}LinkList;
LinkList *head,*p,*s;
int i,j,x,count,length,choices;
LinkList (*CreatList)()//创建单链表
{
int t;
LinkList *r;
head=(LinkList*)malloc(sizeof(LinkList));
r=head;
scanf("%d",&t);
while(t!=-1){
s=(LinkList*)malloc(sizeof(LinkList));
s->data=t;
r->next=s;
r=s;
scanf("%d",&t);
}
r->next=NULL;
return head;
}
LinkList DispList(LinkList *head)//输出单链表
{
for(p=head->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
int ListLength(LinkList *head)//计算单链表长度并输出
{
length=0;
p=head->next;
while(p!=NULL){
p=p->next;
length++;
}
printf("%5d\n",length);
}
LinkList GetElem(LinkList *head,int i)//查找某一元素并输出
{
j=0;
LinkList *p;
p=head;
scanf("%d",&i);
while((p->next!=NULL)&&(j<i)){
p=p->next;
j++;
}
if(i==j) printf("%5d\n",p->data);
else printf("NULL\n");
}
LinkList LocateElem(LinkList *head,int x)//查找某一元素的位置并输出
{
p=head->next;
count=1;
scanf("%d",&x);
while(p!=NULL){
if(p->data!=x){p=p->next; count++;}
else break;
}
if(count<=length) printf("%5d\n",count);
else printf("error\n");
}
LinkList ListInsert(LinkList *head,int i,datatype x)//在某一位置插入某一元素
{
j=1;
p=head->next;
s=(LinkList*)malloc(sizeof(LinkList));
scanf("%d%d",&i,&x);
while(j<i-1&&p!=NULL){
p=p->next;
j++;
}
s->data=x;
s->next=p->next;
p->next=s;
DispList(head);
ListLength(head);
}
LinkList ListDelete(LinkList *head,int i)//删除某一位置的元素
{
j=1;
p=head->next;
scanf("%d",&i);
while(j<i-1){
p=p->next;
j++;
}
s=p->next;
p->next=s->next;
free(s);
DispList(head);
ListLength(head);
}
int DestroyList(LinkList*head)//释放单链表
{
p=head->next;
while(p->next!=NULL){
s=p;
p=p->next;
free(s);
}
head=NULL;
return 0;
}
int main(void)
{
printf("0:创建单链表\n1:输出单链表\n2:计算单链表长度并输出\n3:查找某一元素并输出\n");
printf("4:查找某一元素的位置并输出\n5:在某一位置插入某一元素\n6:删除某一位置的元素\n7:释放单链表\n");
printf("说明：创建单链表以-1结束。\n该程序的释放有点问题，但可以当清空单链表来用。\n请选择：");
while(scanf("%d",&choices)){
switch(choices){
case 0:CreatList();break;//创建单链表
case 1:DispList(head);break;//输出单链表
case 2:ListLength(head);break;//计算单链表长度并输出
case 3:GetElem(head,i);break;//查找某一元素并输出
case 4:LocateElem(head,x);break;//查找某一元素的位置并输出
case 5:ListInsert(head,i,x);break;//在某一位置插入某一元素
case 6:ListDelete(head,i);break;//删除某一位置的元素
case 7:DestroyList(head);printf("该程序释放后不能选择输出");break;//释放单链表
}
printf("请选择：");
}
return 0;
}

❸ C语言链表的使用方法

D
答案D设置完，p就从链表中丢掉了。
p就是一个指向结构体node的指针。
p->next就是p包含的执行下一个node的指针，在本题，就是q。

❹ 数据结构单链表实验(c语言版)

正好我大二的实验还在。。。但是还是想说一句，伸手党不适合做IT，建议楼主还是要自己多加练习，不会可以问，网上有很多乐意帮你解决问题的人。

#include"stdio.h"
#include"string.h"
#include"ctype.h"
#include"stdlib.h"
#include"io.h"
#include"math.h"
#include"time.h"

#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0

#defineMAXSIZE20/*存储空间初始分配量*/

typedefintStatus;/*Status是函数的类型,其值是函数结果状态代码，如OK等*/
typedefintElemType;/*ElemType类型根据实际情况而定，这里假设为int*/


Statusvisit(ElemTypec)
{
printf("%d",c);
returnOK;
}

typedefstructNode
{
ElemTypedata;
structNode*next;
}Node;
typedefstructNode*LinkList;/*定义LinkList*/

/*初始化顺序线性表*/
StatusInitList(LinkList*L)
{
*L=(LinkList)malloc(sizeof(Node));/*产生头结点,并使L指向此头结点*/
if(!(*L))/*存储分配失败*/
returnERROR;
(*L)->next=NULL;/*指针域为空*/

returnOK;
}

/*初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE*/
StatusListEmpty(LinkListL)
{
if(L->next)
returnFALSE;
else
returnTRUE;
}

/*初始条件：顺序线性表L已存在。操作结果：将L重置为空表*/
StatusClearList(LinkList*L)
{
	LinkListp,q;
	p=(*L)->next;/*p指向第一个结点*/
	while(p)/*没到表尾*/
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;/*头结点指针域为空*/
	returnOK;
}

/*初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数*/
intListLength(LinkListL)
{
inti=0;
LinkListp=L->next;/*p指向第一个结点*/
while(p)
{
i++;
p=p->next;
}
returni;
}

/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/
/*操作结果：用e返回L中第i个数据元素的值*/
StatusGetElem(LinkListL,inti,ElemType*e)
{
	intj;
	LinkListp;		/*声明一结点p*/
	p=L->next;		/*让p指向链表L的第一个结点*/
	j=1;		/*j为计数器*/
	while(p&&j<i)/*p不为空或者计数器j还没有等于i时，循环继续*/
	{
		p=p->next;/*让p指向下一个结点*/
		++j;
	}
	if(!p||j>i)
		returnERROR;/*第i个元素不存在*/
	*e=p->data;/*取第i个元素的数据*/
	returnOK;
}

/*初始条件：顺序线性表L已存在*/
/*操作结果：返回L中第1个与e满足关系的数据元素的位序。*/
/*若这样的数据元素不存在，则返回值为0*/
intLocateElem(LinkListL,ElemTypee)
{
inti=0;
LinkListp=L->next;
while(p)
{
i++;
if(p->data==e)/*找到这样的数据元素*/
returni;
p=p->next;
}

return0;
}


/*初始条件：顺序线性表L已存在,1≤i≤ListLength(L)，*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
StatusListInsert(LinkList*L,inti,ElemTypee)
{
	intj;
	LinkListp,s;
	p=*L;
	j=1;
	while(p&&j<i)/*寻找第i个结点*/
	{
		p=p->next;
		++j;
	}
	if(!p||j>i)
		returnERROR;/*第i个元素不存在*/
	s=(LinkList)malloc(sizeof(Node));/*生成新结点(C语言标准函数)*/
	s->data=e;
	s->next=p->next;/*将p的后继结点赋值给s的后继*/
	p->next=s;/*将s赋值给p的后继*/
	returnOK;
}

/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/
StatusListDelete(LinkList*L,inti,ElemType*e)
{
	intj;
	LinkListp,q;
	p=*L;
	j=1;
	while(p->next&&j<i)	/*遍历寻找第i个元素*/
	{
p=p->next;
++j;
	}
	if(!(p->next)||j>i)
	returnERROR;/*第i个元素不存在*/
	q=p->next;
	p->next=q->next;			/*将q的后继赋值给p的后继*/
	*e=q->data;/*将q结点中的数据给e*/
	free(q);/*让系统回收此结点，释放内存*/
	returnOK;
}

/*初始条件：顺序线性表L已存在*/
/*操作结果：依次对L的每个数据元素输出*/
StatusListTraverse(LinkListL)
{
LinkListp=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("
");
returnOK;
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）*/
voidCreateListHead(LinkList*L,intn)
{
	LinkListp;
	inti;
	srand(time(0));/*初始化随机数种子*/
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next=NULL;/*先建立一个带头结点的单链表*/
	for(i=0;i<n;i++)
	{
		p=(LinkList)malloc(sizeof(Node));/*生成新结点*/
		p->data=rand()%100+1;/*随机生成100以内的数字*/
		p->next=(*L)->next;
		(*L)->next=p;						/*插入到表头*/
	}
}

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
voidCreateListTail(LinkList*L,intn)
{
	LinkListp,r;
	inti;
	srand(time(0));/*初始化随机数种子*/
	*L=(LinkList)malloc(sizeof(Node));/*L为整个线性表*/
	r=*L;/*r为指向尾部的结点*/
	for(i=0;i<n;i++)
	{
		p=(Node*)malloc(sizeof(Node));/*生成新结点*/
		p->data=rand()%100+1;/*随机生成100以内的数字*/
		r->next=p;/*将表尾终端结点的指针指向新结点*/
		r=p;/*将当前的新结点定义为表尾终端结点*/
	}
	r->next=NULL;/*表示当前链表结束*/
}

intmain()
{
LinkListL;
ElemTypee;
Statusi;
intj,k;
i=InitList(&L);
printf("初始化L后：ListLength(L)=%d
",ListLength(L));
for(j=1;j<=5;j++)
i=ListInsert(&L,1,j);
printf("在L的表头依次插入1～5后：L.data=");
ListTraverse(L);

printf("ListLength(L)=%d
",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是0:否)
",i);

i=ClearList(&L);
printf("清空L后：ListLength(L)=%d
",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是0:否)
",i);

for(j=1;j<=10;j++)
ListInsert(&L,j,j);
printf("在L的表尾依次插入1～10后：L.data=");
ListTraverse(L);

printf("ListLength(L)=%d
",ListLength(L));

ListInsert(&L,1,0);
printf("在L的表头插入0后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d
",ListLength(L));

GetElem(L,5,&e);
printf("第5个元素的值为：%d
",e);
for(j=3;j<=4;j++)
{
k=LocateElem(L,j);
if(k)
printf("第%d个元素的值为%d
",k,j);
else
printf("没有值为%d的元素
",j);
}


k=ListLength(L);/*k为表长*/
for(j=k+1;j>=k;j--)
{
i=ListDelete(&L,j,&e);/*删除第j个数据*/
if(i==ERROR)
printf("删除第%d个数据失败
",j);
else
printf("删除第%d个的元素值为：%d
",j,e);
}
printf("依次输出L的元素：");
ListTraverse(L);

j=5;
ListDelete(&L,j,&e);/*删除第5个数据*/
printf("删除第%d个的元素值为：%d
",j,e);

printf("依次输出L的元素：");
ListTraverse(L);

i=ClearList(&L);
printf("
清空L后：ListLength(L)=%d
",ListLength(L));
CreateListHead(&L,20);
printf("整体创建L的元素(头插法)：");
ListTraverse(L);

i=ClearList(&L);
printf("
删除L后：ListLength(L)=%d
",ListLength(L));
CreateListTail(&L,20);
printf("整体创建L的元素(尾插法)：");
ListTraverse(L);


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 "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

Status visit(ElemType c)
{
printf("%d ",c);
return OK;
}

typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */

/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
if(!(*L)) /* 存储分配失败 */
return ERROR;
(*L)->next=NULL; /* 指针域为空 */

return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE;
else
return TRUE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0;
LinkList p=L->next; /* p指向第一个结点 */
while(p)
{
i++;
p=p->next;
}
return i;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 */
*e = p->data; /* 取第i个元素的数据 */
return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(p->data==e) /* 找到这样的数据元素 */
return i;
p=p->next;
}

return 0;
}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L;
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
LinkList p=L->next;
while(p)
{
visit(p->data);
p=p->next;
}
printf("\n");
return OK;
}

/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}

/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}

int main()
{
LinkList L;
ElemType e;
Status i;
int j,k;
i=InitList(&L);
printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
for(j=1;j<=5;j++)
i=ListInsert(&L,1,j);
printf("在L的表头依次插入1～5后：L.data=");
ListTraverse(L);

printf("ListLength(L)=%d \n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);

i=ClearList(&L);
printf("清空L后：ListLength(L)=%d\n",ListLength(L));
i=ListEmpty(L);
printf("L是否空：i=%d(1:是 0:否)\n",i);

for(j=1;j<=10;j++)
ListInsert(&L,j,j);
printf("在L的表尾依次插入1～10后：L.data=");
ListTraverse(L);

printf("ListLength(L)=%d \n",ListLength(L));

ListInsert(&L,1,0);
printf("在L的表头插入0后：L.data=");
ListTraverse(L);
printf("ListLength(L)=%d \n",ListLength(L));

GetElem(L,5,&e);
printf("第5个元素的值为：%d\n",e);
for(j=3;j<=4;j++)
{
k=LocateElem(L,j);
if(k)
printf("第%d个元素的值为%d\n",k,j);
else
printf("没有值为%d的元素\n",j);
}

k=ListLength(L); /* k为表长 */
for(j=k+1;j>=k;j--)
{
i=ListDelete(&L,j,&e); /* 删除第j个数据 */
if(i==ERROR)
printf("删除第%d个数据失败\n",j);
else
printf("删除第%d个的元素值为：%d\n",j,e);
}
printf("依次输出L的元素：");
ListTraverse(L);

j=5;
ListDelete(&L,j,&e); /* 删除第5个数据 */
printf("删除第%d个的元素值为：%d\n",j,e);

printf("依次输出L的元素：");
ListTraverse(L);

i=ClearList(&L);
printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
CreateListHead(&L,20);
printf("整体创建L的元素(头插法)：");
ListTraverse(L);

i=ClearList(&L);
printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
CreateListTail(&L,20);
printf("整体创建L的元素(尾插法)：");
ListTraverse(L);

return 0;
}

❼ 关于C语言版数据结构中的单循环链表

void showlist(linklist head){//遍历输出链表
listnode *p;
p=head;
if(p->next=head){//这行里的p->next=head应写成p->next==head
printf("list is empty!\n");
return;
}
else{
while((p=p->next)!=head){
printf("%d ",p->data);
}
}
}

❽ 数据结构，c语言单链表操作问题

首先把p结点链接到pre的后面，然后将pre指向当前的p，p指向下一个结点，这样pre和p就能一直保持前驱和后继的关系

❾ 帮我用C语言写一个数据结构中单链表的建立和插入以及删除操作，就只写这三个操作，小弟是新手谢谢各位了

#include<stdio.h>
#include<malloc.h>
typedef struct Node //定义节点
{
int data; //可以为其他类型
struct Node *next;
}List;
void create(struct Node *&L,int a[],int n) //创建，L是链表头,a是要插入数组,n是要插入元素个数
{
List *s;
int i;
L=(List *)malloc(sizeof(List));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(List *)malloc(sizeof(List));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
int insert(List *&L,int i,int e) //插入，i是插入位置，e是插入的值
{
int j=0;
List *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
s=(List *)malloc(sizeof(List));
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
}
int delete(List *&L,int i,int &e)//i是要删除元素的位置，e保存被删除元素的值
{
int j=0;
List *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(p);
return 1;
}
}