數據結構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;
}
}