c語言鏈表的創建與查詢

1. c語言鏈表建立

#include
#include
struct
chain
{
int
value;
struct
chain
*next;
};
struct
chain
*create()
{
struct
chain
*head,*tail,*p;
int
x;
head
=
tail
=
null;
while(scanf("%d",&x)==1)
{
p=(struct
chain*)malloc(sizeof(struct
chain));
p->value=x;
p->next=null;
if(head==null)
head
=
tail
=
p;
else
tail=tail->next=p;
}
return
head;
}
struct
chain
*inlink(struct
chain
*head,int
a,int
b)
//int
a代表要插入的節點，int
b代表創建節點的數據域
{
struct
chain
*p,*q,*s;
s
=
(struct
chain
*)malloc(sizeof(struct
chain));
s->value=b;
if(head==null)
{
head
=
s;
head->next
=
null;
}
if(head->value
==
a)
{
s->next=head;
head
=
s;
}
else
{
p=head;
while((p->value!=a)&&(p->next!=null))
{
q=p;
p=p->next;
}
if(p->value
==
a)
{
q->next
=
s;
s->next
=
p;
}
else
{
p->next=s;
s->next=null;
}
}
return
(head);
}
struct
chain
*dellink(struct
chain
*head,int
a)
//int
a代表要刪除的節點
{
struct
chain
*q,*p;
if(head
==
null)
printf("找不到節點!\n");
else
if(head->value
==
a)
{
p
=
head;
head
=
head->next;
}
else
{
p=head;
while((p->value!=a)&&(p->next!=null))
{
q=p;
p=p->next;
}
if(p->value
!=
a)
printf("鏈表不存在此節點!\n");
else
{
q->next
=
p->next;
free(p);
}
}
return
(head);
}
void
main()
{
struct
chain
*p,*q;
q=create();
//鏈表的創建；
//q=inlink(create(),3,1);
//鏈表的插入；
//q=dellink(create(),2);
//鏈表的刪除；
while(q){
//輸出鏈表；
printf("%d\n",q->value);
p=q->next;
free(q);
q=p;
}
}

2. 用C語言實現鏈表的建立插入查詢刪除輸出

#include
"stdio.h"
struct
Node
{
Node
*pNext;
int
value;
}*pTop;
struct
Node*
Insert(struct
Node
*pNode,int
Num);
void
Del(struct
Node
*pDelNode);
struct
Node*
Search(struct
Node
*pNode,int
Num);
void
main()
{
pTop=NULL;
int
i,k,x,y;
struct
Node
*pCurrentNode,*pTempNode;
/*（1）建立帶表頭結點的單鏈表；*/
for(i=0;i<30;i++)
Insert(NULL,i);/*建立一個有30個結點的鏈表*/
/*（2）輸出單鏈表中所有結點的數據域值；*/
pCurrentNode=pTop;
while(pCurrentNode!=NULL)
{
printf("%d->",pCurrentNode->value);/*遍歷這個鏈表並輸出其各結點的數據域*/
pCurrentNode=pCurrentNode->pNext;
}
/*（3）輸入x,y在第一個數據域值為x的結點之後插入結點y，若無結點x，則在表尾插入結點y;*/
printf("Input
x,y");
scanf("%d,%d",&x,&y);
pCurrentNode=Search(NULL,x);
Insert(pCurrentNode,y);
/*（4）輸入k，刪除單鏈表中所有的結點k，並輸出被刪除結點的個數。
*/
printf("Input
k");
scanf("%d",&k);
pCurrentNode=pTop;
i=0;
while(1)
{
pTempNode=Search(pCurrentNode,x);
if(pTempNode!=NULL)
{
pCurrentNode=pTempNode->pNext;
Del(pTempNode);
i++;
}
else
break;
}
printf("%d
Nodes
was
deleted",i);
pTempNode=pTop;
while(pTop!=NULL)
{
pTop=pTempNode->pNext;
delete
pTempNode;
}
}
Node*
Insert(struct
Node
*pNode,int
Num)
{
struct
Node
*pNewNode;
pNewNode=new
Node;
pNewNode->value=Num;
if(pNode==NULL)/*無確定插入位置時將結點放在鏈表最後*/
{
if(pTop!=NULL)/*確定鏈表是否是空表*/
{
pNode=pTop;
while(pNode->pNext!=NULL)
pNode=pNode->pNext;/*找到尾結點*/
pNode->pNext=pNewNode;
}
else
{
pTop=pNewNode;
}
pNewNode->pNext=NULL;
}
else/*有確定插入位置時將結點放在指定結點之後*/
{
pNewNode->pNext=pNode->pNext;
pNode->pNext=pNewNode;
}
return
pNewNode;
}
void
Del(struct
Node
*pDelNode)
{
if(pDelNode==NULL
||
pTop==NULL)
return;/*防錯處理*/
struct
Node
*pNode;
pNode=pTop;
while(pNode!=NULL
&&
pNode->pNext!=pDelNode)
pNode=pNode->pNext;/*找到指定結點的前導結點*/
if(pNode!=NULL)
{
pNode->pNext=pDelNode->pNext;
delete
pDelNode;
}
}
struct
Node*
Search(struct
Node
*pNode,int
Num)
{
struct
Node
*pSeaNode;
if(pNode==NULL)
pSeaNode=pTop;/*不指定搜索的起始位置，從表頭開始*/
else
pSeaNode=pNode;/*指定了搜索的起始位置，從指定位置開始*/
while(pSeaNode!=NULL
&&
pSeaNode->value!=Num)
pSeaNode=pSeaNode->pNext;
return
pSeaNode;/*沒有找到結點時返回空指針*/
}

3. C語言鏈式表最少寫創建，查詢，插入，刪除，輸出這幾個功能 ；完整代碼

比你要求的要多很多

看注釋

#include"stdio.h"
#include<stdlib.h>
#include"string.h"

typedefintelemType;

/************************************************************************/
/*以下是關於線性表鏈接存儲（單鏈表）操作的18種演算法*/

/*1.初始化線性表，即置單鏈表的表頭指針為空*/
/*2.創建線性表，此函數輸入負數終止讀取數據*/
/*3.列印鏈表，鏈表的遍歷*/
/*4.清除線性表L中的所有元素，即釋放單鏈表L中所有的結點，使之成為一個空表*/
/*5.返回單鏈表的長度*/
/*6.檢查單鏈表是否為空，若為空則返回1，否則返回0*/
/*7.返回單鏈表中第pos個結點中的元素，若pos超出范圍，則停止程序運行*/
/*8.從單鏈表中查找具有給定值x的第一個元素，若查找成功則返回該結點data域的存儲地址，否則返回NULL*/
/*9.把單鏈表中第pos個結點的值修改為x的值，若修改成功返回1，否則返回0*/
/*10.向單鏈表的表頭插入一個元素*/
/*11.向單鏈表的末尾添加一個元素*/
/*12.向單鏈表中第pos個結點位置插入元素為x的結點，若插入成功返回1，否則返回0*/
/*13.向有序單鏈表中插入元素x結點，使得插入後仍然有序*/
/*14.從單鏈表中刪除表頭結點，並把該結點的值返回，若刪除失敗則停止程序運行*/
/*15.從單鏈表中刪除表尾結點並返回它的值，若刪除失敗則停止程序運行*/
/*16.從單鏈表中刪除第pos個結點並返回它的值，若刪除失敗則停止程序運行*/
/*17.從單鏈表中刪除值為x的第一個結點，若刪除成功則返回1,否則返回0*/
/*18.交換2個元素的位置*/
/*19.將線性表進行快速排序*/


/************************************************************************/
typedefstructNode{/*定義單鏈表結點類型*/
elemTypeelement;
structNode*next;
}Node;


/*1.初始化線性表，即置單鏈表的表頭指針為空*/
voidinitList(Node**pNode)
{
*pNode=NULL;
printf("initList函數執行，初始化成功
");
}

/*2.創建線性表，此函數輸入負數終止讀取數據*/
Node*creatList(Node*pHead)
{
Node*p1;
Node*p2;

p1=p2=(Node*)malloc(sizeof(Node));//申請新節點
if(p1==NULL||p2==NULL)
{
printf("內存分配失敗
");
exit(0);
}
memset(p1,0,sizeof(Node));

scanf("%d",&p1->element);//輸入新節點
p1->next=NULL;//新節點的指針置為空
while(p1->element>0)//輸入的值大於0則繼續，直到輸入的值為負
{
if(pHead==NULL)//空表，接入表頭
{
pHead=p1;
}
else
{
p2->next=p1;//非空表，接入表尾
}
p2=p1;
p1=(Node*)malloc(sizeof(Node));//再重申請一個節點
if(p1==NULL||p2==NULL)
{
printf("內存分配失敗
");
exit(0);
}
memset(p1,0,sizeof(Node));
scanf("%d",&p1->element);
p1->next=NULL;
}
printf("creatList函數執行，鏈表創建成功
");
returnpHead;//返回鏈表的頭指針
}

/*3.列印鏈表，鏈表的遍歷*/
voidprintList(Node*pHead)
{
if(NULL==pHead)//鏈表為空
{
printf("PrintList函數執行，鏈表為空
");
}
else
{
while(NULL!=pHead)
{
printf("%d",pHead->element);
pHead=pHead->next;
}
printf("
");
}
}

/*4.清除線性表L中的所有元素，即釋放單鏈表L中所有的結點，使之成為一個空表*/
voidclearList(Node*pHead)
{
Node*pNext;//定義一個與pHead相鄰節點

if(pHead==NULL)
{
printf("clearList函數執行，鏈表為空
");
return;
}
while(pHead->next!=NULL)
{
pNext=pHead->next;//保存下一結點的指針
free(pHead);
pHead=pNext;//表頭下移
}
printf("clearList函數執行，鏈表已經清除
");
}

/*5.返回單鏈表的長度*/
intsizeList(Node*pHead)
{
intsize=0;

while(pHead!=NULL)
{
size++;//遍歷鏈表size大小比鏈表的實際長度小1
pHead=pHead->next;
}
printf("sizeList函數執行，鏈表長度%d
",size);
returnsize;//鏈表的實際長度
}

/*6.檢查單鏈表是否為空，若為空則返回1，否則返回0*/
intisEmptyList(Node*pHead)
{
if(pHead==NULL)
{
printf("isEmptyList函數執行，鏈表為空
");
return1;
}
printf("isEmptyList函數執行，鏈表非空
");

return0;
}

/*7.返回單鏈表中第pos個結點中的元素，若pos超出范圍，則停止程序運行*/
elemTypegetElement(Node*pHead,intpos)
{
inti=0;

if(pos<1)
{
printf("getElement函數執行，pos值非法
");
return0;
}
if(pHead==NULL)
{
printf("getElement函數執行，鏈表為空
");
return0;
//exit(1);
}
while(pHead!=NULL)
{
++i;
if(i==pos)
{
break;
}
pHead=pHead->next;//移到下一結點
}
if(i<pos)//鏈表長度不足則退出
{
printf("getElement函數執行，pos值超出鏈表長度
");
return0;
}

returnpHead->element;
}

/*8.從單鏈表中查找具有給定值x的第一個元素，若查找成功則返回該結點data域的存儲地址，否則返回NULL*/
elemType*getElemAddr(Node*pHead,elemTypex)
{
if(NULL==pHead)
{
printf("getElemAddr函數執行，鏈表為空
");
returnNULL;
}
if(x<0)
{
printf("getElemAddr函數執行，給定值X不合法
");
returnNULL;
}
while((pHead->element!=x)&&(NULL!=pHead->next))//判斷是否到鏈表末尾，以及是否存在所要找的元素
{
pHead=pHead->next;
}
if((pHead->element!=x)&&(pHead!=NULL))
{
printf("getElemAddr函數執行，在鏈表中未找到x值
");
returnNULL;
}
if(pHead->element==x)
{
printf("getElemAddr函數執行，元素%d的地址為0x%x
",x,&(pHead->element));
}

return&(pHead->element);//返回元素的地址
}

/*9.把單鏈表中第pos個結點的值修改為x的值，若修改成功返回1，否則返回0*/
intmodifyElem(Node*pNode,intpos,elemTypex)
{
Node*pHead;
pHead=pNode;
inti=0;

if(NULL==pHead)
{
printf("modifyElem函數執行，鏈表為空
");
}
if(pos<1)
{
printf("modifyElem函數執行，pos值非法
");
return0;
}
while(pHead!=NULL)
{
++i;
if(i==pos)
{
break;
}
pHead=pHead->next;//移到下一結點
}
if(i<pos)//鏈表長度不足則退出
{
printf("modifyElem函數執行，pos值超出鏈表長度
");
return0;
}
pNode=pHead;
pNode->element=x;
printf("modifyElem函數執行
");

return1;
}

/*10.向單鏈表的表頭插入一個元素*/
intinsertHeadList(Node**pNode,elemTypeinsertElem)
{
Node*pInsert;
pInsert=(Node*)malloc(sizeof(Node));
memset(pInsert,0,sizeof(Node));
pInsert->element=insertElem;
pInsert->next=*pNode;
*pNode=pInsert;
printf("insertHeadList函數執行，向表頭插入元素成功
");

return1;
}

/*11.向單鏈表的末尾添加一個元素*/
intinsertLastList(Node**pNode,elemTypeinsertElem)
{
Node*pInsert;
Node*pHead;
Node*pTmp;//定義一個臨時鏈表用來存放第一個節點

pHead=*pNode;
pTmp=pHead;
pInsert=(Node*)malloc(sizeof(Node));//申請一個新節點
memset(pInsert,0,sizeof(Node));
pInsert->element=insertElem;

while(pHead->next!=NULL)
{
pHead=pHead->next;
}
pHead->next=pInsert;//將鏈表末尾節點的下一結點指向新添加的節點
*pNode=pTmp;
printf("insertLastList函數執行，向表尾插入元素成功
");

return1;
}

/*12.向單鏈表中第pos個結點位置插入元素為x的結點，若插入成功返回1，否則返回0*/


/*13.向有序單鏈表中插入元素x結點，使得插入後仍然有序*/
/*14.從單鏈表中刪除表頭結點，並把該結點的值返回，若刪除失敗則停止程序運行*/
/*15.從單鏈表中刪除表尾結點並返回它的值，若刪除失敗則停止程序運行*/
/*16.從單鏈表中刪除第pos個結點並返回它的值，若刪除失敗則停止程序運行*/
/*17.從單鏈表中刪除值為x的第一個結點，若刪除成功則返回1,否則返回0*/
/*18.交換2個元素的位置*/
/*19.將線性表進行快速排序*/

/******************************************************************/
intmain()
{
Node*pList=NULL;
intlength=0;

elemTypeposElem;

initList(&pList);//鏈表初始化
printList(pList);//遍歷鏈表，列印鏈表

pList=creatList(pList);//創建鏈表
printList(pList);

sizeList(pList);//鏈表的長度
printList(pList);

isEmptyList(pList);//判斷鏈表是否為空鏈表

posElem=getElement(pList,3);//獲取第三個元素，如果元素不足3個，則返回0
printf("getElement函數執行，位置3中的元素為%d
",posElem);
printList(pList);

getElemAddr(pList,5);//獲得元素5的地址

modifyElem(pList,4,1);//將鏈表中位置4上的元素修改為1
printList(pList);

insertHeadList(&pList,5);//表頭插入元素12
printList(pList);

insertLastList(&pList,10);//表尾插入元素10
printList(pList);

clearList(pList);//清空鏈表
system("pause");

}

4. 如何用C語言創建一個鏈表，實現增、刪、改、查

#include<stdio.h>
#include<string.h>
#include <malloc.h>
//先定義一種student類型,表示一個學生的信息，如下：
typedef struct student
{
int num; //表示學號
char name[30]; //表示姓名
float score; //表示分數
}student;
//定義一種NODE類型,表示一個結點信息，如下：
typedef struct node
{
student st; //表示一個學生的信息
struct node *next; //表示一個NODE類型的指針
}NODE;
//1、寫出建立一個帶頭結點的線性鏈表的函數，其中每個結點包括學號、姓名、分數三個數據域。函數形式如下：
NODE *creat_link(int direction)
{
NODE *head,*p,*tail;
int xh,i=1;
if(direction==1) //當direction的值為1時，新建立的結點連到尾部
{
tail=head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("請輸入第%d個學生的學號：",i);
scanf("%d",&xh);
while(xh>0) //從鍵盤臨時輸入學生情況，當輸入的學號非正，則鏈表建立完畢
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("請輸入第%d個學生的姓名：",i);
scanf("%s",p->st.name);
printf("請輸入第%d個學生的成績：",i);
scanf("%f",&p->st.score);
p->next=NULL;
tail->next=p;
tail=p;
i=i+1;
printf("請輸入第%d個學生的學號：",i);
scanf("%d",&xh);
}
}
else if(direction==0) //當direction為0時，新建立的結點成為第一個結點
{
head=(NODE *)malloc(sizeof(NODE));
head->next=NULL;
printf("請輸入第%d個學生的學號：",i);
scanf("%d",&xh);
while(xh>0) //從鍵盤臨時輸入學生情況，當輸入的學號非正，則鏈表建立完畢
{
p=(NODE *)malloc(sizeof(NODE));
p->st.num=xh;
printf("請輸入第%d個學生的姓名：",i);
scanf("%s",p->st.name);
printf("請輸入第%d個學生的成績：",i);
scanf("%f",&p->st.score);
p->next=head->next;
head->next=p;
i=i+1;
printf("請輸入第%d個學生的學號：",i);
scanf("%d",&xh);
}
}
return head;
}
//2、寫出輸出上述鏈表各結點數據域值的函數。該函數對應的函數需要一個形參，表示鏈表的頭指針，形式如下：
void print_link(NODE *head)
{
NODE *p;
p=head->next;
printf("%-10s%-20s%-10s\n","學號","姓名","分數");
while(p!=NULL)
{
printf("%-10d%-20s%-10.1f\n",p->st.num,p->st.name,p->st.score);
p=p->next;
}
//該函數能輸出head所指的鏈表的所有結點值，輸出形式如下：
/*本函數輸出線性表sq中所有數據，形式如下：
學號 姓名 分數
12 張三 234.5
18 李四 987.7
……… ……… …….*/
}
//3、寫出在鏈表中刪除結點的函數
int del_link(NODE *head,char name[])
{
NODE *p,*p1;
p=head->next;
p1=head;
while(p!=NULL)
{
if(strcmp(p->st.name,name)!=0)
{
p1=p;
p=p->next;
}
else
{
break;
}
}
if(p!=NULL)
{
p1->next=p->next;
free(p);
return 1;
}
else
{
return 0;
}
//刪除head所指的鏈表中，名字為name的結點，刪除成功返回1，不成功返回0
}
//4、寫出在鏈表中插入結點的演算法
int insert(NODE *head,student x,int wz)
{
NODE *p=head;
int i=0,jg;
if(wz<=0)
{
jg=0;
}
else
{
while(i<wz-1&&p!=NULL)
{
i++;
p=p->next;
}
if(p==NULL)
{
jg=0;
}
if(i=wz-1)
{
//找到wz前面的節點，p指向它
NODE *q;
q=(NODE *)malloc(sizeof(NODE));
q->st.num=x.num;
strcpy(q->st.name,x.name);
q->st.score=x.score;
q->next=p->next;
p->next=q;
jg=1;
}
}
return jg;
//該函數能夠在wz這個結點之前，插入一個新結點，新結點的數據域為x。插入成功返回1，不成功返回0。
}
//5、寫出主函數，分別調用上面演算法所對應的程序，建立鏈表，並輸出鏈表的值。
void main()
{
NODE *head; //定義指針變數head
int wz; //表示插入位置
char xm[30];
student st; //定義一個變數st，用來表示一個學生的信息
head=creat_link(1);
print_link(head); //調用函數建立鏈表，並把返回值送給head;
//調用函數，輸出鏈表中各個結點的值
//輸入一個學生的有關信息，送給變數st的有關成員
printf("\n\n請輸入要插入的位置：");
scanf("%d",&wz); //輸入wz的值
printf("請輸入要插入的學生的學號：");
scanf("%d",&st.num);
printf("請輸入要插入的學生的姓名：");
scanf("%s",st.name);
printf("請輸入要插入的學生的成績：");
scanf("%f",&st.score);
//調用函數，在鏈表中把學生st的值作為一個結點插入,如果插入成功，輸出新鏈表
if(insert(head,st,wz)==1)
{
printf("\n插入成功，新表為：\n");
print_link(head);
}
else
{
printf("插入不成功");
}
//調用函數，在鏈表中刪除一個指定結點的值,如果刪除成功，輸出新鏈表
printf("\n\n請輸入要刪除的學生的姓名：");
getchar();
gets(xm);
if(del_link(head,xm)==1)
{
printf("\n刪除成功，新表為：\n");
print_link(head);
}
else
{
printf("刪除不成功");
}
}

5. c語言鏈表的初始化，建立，插入，查找，刪除！！急急急！謝謝各位大神了！

好吧，我居然找到了我以前的了。。。
#include ＜stdio.h＞
#include ＜malloc.h＞
#include ＜string.h＞
#define N 10
typedef struct node
{
char name[20];
struct node *link;
}stud;
stud * create(int n) //創建有n個節點的鏈表，返回鏈表頭結點
{
stud *p,*h,*s;
if((h=(stud *)malloc(sizeof(stud)))==NULL)//創建頭節點
{
printf("Memory allocation fails!");
exit(0);
}
strcpy( h-＞name, 「head」 );
h-＞link=NULL;
p=h;
for(int i=0;i＜n-1;i++)
{
if((s= (stud *) malloc(sizeof(stud)))==NULL)//依次創建每一個節點
{
printf("Memory allocation fails!");
exit(0);
}
p-＞link=s;
printf("Please input %d person name:", i+1);
scanf("%s",s-＞name);
s-＞link=NULL;
p=s;
}
return(h);
}

stud* search(stud *h, char *x) //查找，h是鏈表頭結點，x是要查的字元串
{
stud *p = h;
while(p!=NULL) //最後一個節點的link
{
if(strcmp(p-＞name, x)==0)
return(p);
else
p=p-＞link; //p指向下一個節點
}
if(p==NULL)
printf("There is no such a student!");
return p;
}

stud* Delete(stud *h, char *x) //刪除某個節點，返回鏈表頭結點 //x是要刪除的數據
{
if( h == NULL)
return NULL;

stud * p1, *p2;
p1=h;
p2=h->link;
if (strcmp( p1->name, x ) == 0 )//頭結點特殊處理
{
h = h->link;//頭指針指向第二個元素即可
free(p1);//釋放頭結點
return h;
}

while(p2!=NULL)//p2 代表當前要比較的節點，p1代表當前節點的前一個節點
{
if(strcmp(p2->name, x)==0)
{
p1->link = p2->link;
free(p2);
return h;
}
else
{
p1=p2;
p2=p2->link;//一起往後移
}
}
rerun h;
}

void insert(stud *p) //在p節點後插入一個節點
{
char stuname[20];
stud *s;

if((s= (stud *) malloc(sizeof(stud)))==NULL)
{
printf("Memory allocation fails!");
exit(0);
}
printf("Please input name」 );
scanf("%s",stuname);
strcpy(s-＞name,stuname);
s-＞link=p-＞link;//後邊連接
p-＞link=s;//前邊連接
}

void freeList(stud* head) //刪除整個鏈表
{    
stud* p;
while( head != NULL)
{
      p = head;
        head = head->link;
        free(p);
    }
}

void printList(stud* head) //列印鏈表中的所有數據
{    
stud* p;
p = head;
int count = 0;
while(p != NULL)
{
        printf("%s\n", p->name);
         p = p->link;
count++;
}
}

int main()
{
int number;
char fullname[20];
stud *head,*searchpoint;

number=N;
head=creat(number);
printf("Input the srearch name:");
scanf("%s",fullname);
searchpoint=search(head,fullname);
insert(searchpoint);
char str[10];
scanf( 「%s」, str );
head = delete( head, str );
printList( head );
freeList( head );
return 0;
}
以下是將鏈表逆置的demo
typedef struct linknode
{
int data;
struct linknode *next;
}node;

//將一個鏈表逆置
typedef struct linknode
{
int data;
struct linknode *next;
}node;//類型定義
node *reverse(node *head)
{
node *p,*q,*r; //q代表當前節點，p代表當前節點的前一個節點，r代表當前節點的下一個節點
p=head;
q=p->next;
while(q!=NULL)
{
r=q->next;
q->next=p;
p=q;
q=r;
}
head->next=NULL;
head=p;
return head;
}

6. 怎樣用c語言創建一個單鏈表，並執行查找、插入、刪除操作

LinkList *Head(LinkList *p) //創建頭結點{ p=(LinkList*)malloc(sizeof(LinkList));
p->next=NULL; return p;}void Create(LinkList *L,int length) //鏈表的創建,length表示鏈表的長度{ LinkList *p; p=L; int i=0; while(i<length) { s=(LinkList*)malloc(sizeof(LinkList));
scanf("%d",&s->data);
s->next=NULL;
p->next=s;
p=s;
i++; }}int Search(LinkList *L,int n) //查找
{
LinkList *p;
p=L->next;
while(p!=NULL && p->data!=n)
p=p->next;
if(p==NULL)
return 0;
else
return 1;
}void Insert(LinkList *L) //插入
{
LinkList *p,*s;
p=L;
while(p->next!=NULL)
p=p->next;
s=(LinkList*)malloc(sizeof(LinkList));
scanf("%d",&s->data);
s->next=NULL;
p->next=s;
p=s;
}void Delete(LinkList *L,int n) //刪除鏈表中的結點
{
LinkList *p,*q;
p=L;
q=p->next;
while(p->next!=NULL && q->data!=n)
p=p->next;
p->next=q->next;
free(q);
}