c語言單鏈表的修改演算法

㈠ c語言單鏈表節點倒置的演算法問題

扣著的是頭節點（頭子）

車是首節點（首子）

馬是次節點（次子）

牙簽細的是指針指向，香頭發黑的是指向，鐵頭細的是指向。

根據步驟寫程序的偽演算法（3步4循環，7張圖片搞定），如下：

第一個循環把馬弄到車前面，

第二個循環把相弄到馬前面

第三個循環把士弄到相前面

........

直到香指向為空後停止循環。

代碼如下：只需要一個首結點pHead,就能把鏈表找到，並倒置。具體代碼如下

p香=pHead->pNext;

p鐵=p香->pNext;

p香->pNext=NULL;

P香=p鐵

while(p香 ！=NULL)

{

p鐵=p香->pNext;

p香->pNext=pHead->pNext;

pHead->pNext=p香；

p香=p鐵；

}

對照偽演算法（三步四循環），和上面的代碼是一一對應的：

第一步：香頭指向首子，鐵頭指向次子

第二步：刪掉首子指向次子（鐵頭所指向的那個子）的牙簽

第三步：香頭跟著鐵頭

以下循環條件：（條件：香頭指向不為空）

{

循環1：鐵頭移動到香頭的下一個指向

循環2：香頭的下一個指向首子

循環3：頭子的下一個跟著香頭

循環4：香頭跟著鐵頭

}

自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。

㈡ 用C語言實現鏈表的演算法

這個是我們數據結構上機實驗的鏈表問題，
#include<stdio.h>
#include<malloc.h>
#define
LEN
sizeof(LinkNode)
typedef
int
Datatype;
typedef
int
Status;
typedef
struct
LinkNode{
Datatype
data;
struct
LinkNode
*next;
}
LinkNode,*LinkList;
typedef
struct
OrderedList
{
LinkNode
*head,*tail;
int
Listsize;
}
OrderedList;//有序循環鏈表的頭節點head,尾接接節點
tail及長度Listsize
Status
InitList(OrderedList
*List)//生成循環鏈表頭節點
{
List->tail=List->head=(LinkList)malloc(LEN);
if(List->head==NULL)
return
0;
else
{
List->head->next=List->tail;
List->tail->next=List->head;
List->Listsize=0;
return
1;
}
}
void
OrderedInsert(OrderedList
*List,Datatype
data)//每調用一次有序插入data形成有序的(從小到大)的鏈表
{
LinkNode
*p
,*q;
if(List->head==List->tail->next)
{
p=(LinkNode*)malloc(LEN);
p->data
=
data;
List->head->next=p;
p->next=List->tail;
List->Listsize++;
}
else
{
p=List->head->next;
q
=
List->head;
while(p->data<data&&p!=List->tail)
{
q
=
p;
p=p->next;
}
if(p->data==data)
{printf("YOu
have
input
the
same
datas
%d\n\t
YOu
should
input
another
data
\n",data);
scanf("%d",&data);
OrderedInsert(List,data);
}
else
{
p=(LinkNode*)malloc(LEN);
p->data
=
data;
p->next
=
q->next;
q->next
=
p;
List->Listsize++;
}
}
}
void
Creatset(OrderedList
*List)//多次調用OrderedInsert()生成有序鏈表即集合List
{
Datatype
data;
int
setsize
,
i=0;
printf("Please
input
the
setsize
you
want
to
creat:\n");
scanf("%d",&setsize);
InitList(List);
if(setsize==0)
printf("You
needen't
input
any
data\n");
else
if(setsize==1)
printf("Please
input
a
single
data\n");
else
printf("Please
input
%d
different
datas;\n",setsize);
while(i<setsize||setsize>List->Listsize)//當循環次數i小於setsize或者集合內實際元素數List.Listsize小於setsize時一直循環下去
{
scanf("%d",&data);
OrderedInsert(List,data);
i++;
}
}
void
Append(OrderedList
*List,Datatype
data)//在循環鏈表的最後面追加
一個data
{
LinkNode
*p;
p=(LinkNode*)malloc(LEN);
p->data=data;
List->tail=List->tail->next=p;
List->tail->next=List->head;
List->Listsize+=1;
}
void
MergeList(OrderedList
La,OrderedList
Lb,OrderedList
*Lc)//有序循環鏈表ListLa,ListLb求並集生成ListLc
{
LinkList
Pa,Pb;
Pa=La.head->next;Pb=Lb.head->next;
while(Pa!=La.tail&&Pb!=Lb.tail)
{
if(Pa->data<=Pb->data)
{
Append(Lc,Pa->data);
Pa=Pa->next;
}
else
{
Append(Lc,Pb->data);Pb=Pb->next;
}
}
while(Pa!=La.tail)
{
Append(
Lc,Pa->data);Pa=Pa->next;}
while(Pb!=Lb.tail)
{
Append(Lc,Pb->data);Pb=Pb->next;}
}
void
Print(OrderedList
List)
{
LinkNode
*p;
p=List.head->next;
if(p->next==List.head)
printf("No
Elem\n");
while(p!=List.head)
{
printf("%5d",p->data);p=p->next;
}
printf("\n");
}
void
main()
{
OrderedList
ListLa,ListLb,ListLc;
Creatset(&ListLa);
Creatset(&ListLb);
InitList(&ListLc);
MergeList(ListLa,ListLb,&ListLc);
printf("The
orgnial
list
ListLa,ListLb:\n");
Print(ListLa);
Print(ListLb);
printf("The
Merge
list
ListLc;\n");
Print(ListLc);
}

㈢ C語言數據結構與演算法：鏈表

先搞清楚基本概念，不懂再問

//返回一個帶頭結點的且具有五個結點的鏈表
link*initLink()
{
link*p=(link*)malloc(sizeof(link));//創建頭結點
link*temp=p;//使用變數temp在下面創建結點時指向鏈表末端

for(inti=1;i<5;i++)
{
link*a=(link*)malloc(sizeof(link));//創建一個結點
a->elem=i;//為結點賦值
a->next=NULL;//指針域暫時賦為NULL,若後面還要創建結點的話再修改
temp->next=a;//因為temp指向鏈表末端，即最後一個結點
//故該節點指針域應指向剛才創建的結點a
temp=temp->next;//連接好以後，temp指向下一個結點（剛才創建的結點a,現在是鏈表末端）

}
returnp;//返回頭結點
}

㈣ C語言單鏈表演算法問題

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
int data;
struct LNode *next;
}LNode,*LinkList;
void InitList(LinkList *L);
void ListDeleteMax(LinkList L,int *e);
int ListInsert(LinkList L,int i,int e);
void DestroyList(LinkList L);
void ListTraverse(LinkList L);
int main(void)
{
LinkList L;
int i,j,m;
int a[]={6,5,4,3,2,1};
InitList(&L);
for(i=0; i<6; ++i)
m = ListInsert(L,i+1,a[i]);
printf("鏈表的內容為：");
ListTraverse(L);
ListDeleteMax(L,&j);
printf("刪除最大元素%d後，鏈表的內容為：",j);
ListTraverse(L);
DestroyList(L);
return 0;
}
void InitList(LinkList *L)
{
*L = (LinkList )malloc(sizeof(LNode));
if(!*L)
exit(-1);
(*L)->next = NULL;
}
int ListInsert(LinkList L,int i,int e)
{
int j=0;
LinkList p = L;
LinkList s;
while(p&&j<i-1)
{
p = p->next;
j++;
}
if(!p || j>i-1)
{
return 0;
}
s = (LinkList)malloc(sizeof(LNode));
s ->data = e;
s->next = p->next;
p->next = s;
return 1;
}
void ListDeleteMax(LinkList L,int *e) //刪除最大元素
{
LinkList p = L->next;
LinkList s = L; //s指向最大結點前面的結點
LinkList q;
int m = p->data; //m保存最大的值
while(p->next)
{
q=p->next;
if(q->data > m)
{
m = q->data;
s = p;
}
p=p->next;
}
q = s->next;
s->next = q->next;
*e = q->data;
free(q);
}
void DestroyList(LinkList L)
{
LinkList q;
while(L)
{
q = L->next;
free(L);
L = q;
}
}
void ListTraverse(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ",p->data);
p = p->next;
}
printf("\n");
}

㈤ 數據結構c語言單鏈表的增刪改查程序：#include <stdio.h>

沒有main函數在你程序的最後加上

voidmain()
{
	creates();
}

㈥ C語言：在鏈表中單鏈表操作,不能按題目要求運行，求幫忙看看怎麼改

應該是你的 typedef int ElemType; 這出的問題 我不經常用typedef 。（我是若菜一枚）。
下面的都沒問題

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef int ElemType;
typedef struct LNode
{
int data; //數據
struct LNode *next; //指針
} LNode, *LinkList; //鏈表每個結點的定義
void BuildList(LinkList &l) //建立一個帶頭結點的單向鏈表
{
LinkList p,q;
int x;
l =(LinkList)malloc(sizeof(LNode));
l->next=NULL;
p=l;

while(scanf("%d",&x) && x != -1)//輸入-1的時候結束鏈表創建 隨便改
{
q=(LinkList)malloc(sizeof(LNode));
q->data=x;
q->next=NULL;
p->next=q;
p=q;
}
}
void VisitList(LinkList &L) //實現遍歷單鏈表
{
LinkList p;
p = L ;
while(p -> next != NULL)
{
p = p->next;
printf("%d ",p->data);
}
printf("\n\n");
}
void ListDelete(LinkList L)
{
printf("請輸入要刪除的元素：");
int E;
scanf("%d",&E);
LinkList p,q;
p = L; // 聲明一結點p指向鏈表第一個結點
while(p)
{
if(p->data==E)
{
q->next=p->next;
free(p);
}
else
{
q=p;//q始終指向p上一個結點
p=p->next;
}
}
}
void InverseSet(LinkList &L) //實現逆置
{
LinkList p,s;
p=L->next;
L->next=NULL;
while(p)
{
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
int main()
{
LinkList La;
// ElemType x;
int n;
printf("1.鍵盤輸入一組元素，建立一個帶頭結點的單向鏈表（無序）\n");
printf("2.遍歷單向鏈表\n");
printf("3.在單向鏈表中刪除元素E \n");
printf("4.將單向鏈表逆置\n");
while(1)
{
printf("選擇一項實現：");
scanf("%d",&n);
switch(n)
{
case 1:
BuildList(La);
break;
case 2:
VisitList(La);
break;
case 3:
ListDelete(La);
VisitList(La);
// printf("請輸入要刪除的元素x");
// scanf("&d",&x);
break;
case 4:
InverseSet(La);
VisitList(La);
break;
default:
printf("輸入有誤，請重新選擇！\n");
}
}
}

㈦ C語言——鏈表的修改

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct student)
struct student
{
int num;
char name[20];
float score[3];
struct student *next;
};
int n=0;
struct student *creat(void) //建立鏈表
{
struct student *head,*p1,*p2;
p1=p2=(struct student *)malloc(LEN);
head=NULL;
scanf("%d %s %f %f %f",&p1->num,p1->name,&p1->score[0],&p1->score[1],&p1->score[2]);
while(p1->num!=0)
{
n=n+1;
if(n==1)
head=p1;
else p2->next=p1;
p2=p1;
p1=(struct student *)malloc(LEN);
scanf("%d %s %f %f %f",&p1->num,p1->name,&p1->score[0],&p1->score[1],&p1->score[2]);
}
p2->next=NULL;
return (head);
}
void main() //main函數
{
struct student *insert(struct student *head,struct student *stu);
struct student *del(struct student *head,int num);
struct student *p, *b,*stu;
int m,flag=1,flag1=1,flag2=1;
b=p=creat();
printf("now,there are %d crunodes are:\n",n);
for(;p!=NULL;)
{
printf("%d%10s%8.2f%8.2f%8.2f\n",p->num,p->name,p->score[0],p->score[1],p->score[2]);
p=p->next;
}
while(flag2!=0) //控制開關
{
printf("if you input '1' that you will have the funtion to delete the crunode\nif you input '2' that you will have the funtion to insert crunode.\nif you input '0' that you will end.\n");
printf("what you want to enter 1 ,2 or 0:");
scanf("%d" ,&flag2);//選擇功能，是增加結點還是刪減結點
if(flag2==1)
{
while(flag)
{
printf("delete the crunode(結點):");
scanf("%d",&m);
p=del(b,m);
if(n==0)
{
b=p;
flag=0;
break;
}
b=p;
printf("now,there are %d crunodes are:\n",n);
for(;p!=NULL;)
{
printf("%d%10s%8.2f%8.2f%8.2f\n",p->num,p->name,p->score[0],p->score[1],p->score[2]);
p=p->next;
}
printf("contiune or not(0/1):");
scanf("%d",&flag);
}
}
if(flag2==2)
{
while(flag1)
{
if(flag)//第一次是不執行這句的
{
if(n==0) b=NULL;
p=insert(b,stu);
b=p;
printf("now,there are %d crunodes are:\n",n);
for(;p!=NULL;)
{
printf("%d%10s%8.2f%8.2f%8.2f\n",p->num,p->name,p->score[0],p->score[1],p->score[2]);
p=p->next;
}
printf("continue or not :(0/1):");
scanf("%d",&flag1);
if(flag1==0) break;
}
//起到控制整個while循環的作用
printf("please input the imformation of the student who you want to add:");
stu=(struct student *)malloc(LEN); //申請內存
scanf("%d %s %f %f %f",&stu->num,stu->name,&stu->score[0],&stu->score[1],&stu->score[2]);//輸入學生的信息
flag=1;
// 起到控製作用，目的是為了第一次不執行上上個if語句
}
}
}
}
struct student *del(struct student *head,int num) //刪除結點
{
struct student *p1,*p2;
if(head==NULL)
{
printf("this is list null.\n");
return head;
}
else
p1=head;
while(num!=p1->num && p1->next!=NULL)
{
p2=p1;p1=p1->next; //一個一個的下去
}
if(num==p1->num)
{
if(p1==head) //才一個結點
{
head=p1->next;
free(p1);
}
else //不止一個結點
{
p2->next=p1->next;
free(p1);
}
n=n-1;
printf("delete:%d\n",num);
printf("there are %d crunode(結點) now.\n",n);
}
else
printf("%d crunode(結點) has not been found!\n",num);
if(n==0) //如果刪除結點後結點個數為0
return NULL;
else
return (head);
}
struct student *insert(struct student *head,struct student *stu) //增加結點
{
struct student *p1,*p2,*p0;
p1=head;
p0=stu;
if(head==NULL)
{
head=p0;
p0->next=NULL;
}
else
{
while(p0->num>p1->num && p1->next!=NULL)
{
p2=p1;p1=p1->next;
}
if(p0->num<=p1->num)
{
if(head==p1) //插到第一個結點前
{
head=p0;
p0->next=p1;
}
else
{
p2->next=p0;
p0->next=p1;
}
}
else
{
p1->next=p0;
p0->next=NULL;
}
}
n=n+1;
return(head);
}
我正好學到鏈表的，所以就話了一個晚上來做了這個，我哦完善了一下，如果有什麼不滿意的話，或有什麼不懂的話你可以加QQ419842687

㈧ C語言單鏈表 求大神教教怎麼修改

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

typedefstructnode
{
	intdata;
	structnode*next;
}node;

intmain(void){
	intnum;
	node*p,*head;
	head=NULL;
	do{
		scanf("%d",&num);
		if(num!=-1)
		{
			p=(node*)malloc(sizeof(node));
			p->data=num;
			p->next=NULL;
			if(head==NULL)
				head=p;
			else
				p->next=head;
			head=p;
		}
	}while(num!=-1);
	while(p!=NULL){
		printf("%d",p->data);
		p=p->next;
	}
	printf("
");
	return0;
}

已經修改好了，有問題如果問錯在哪可以追問

㈨ 如何用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("刪除不成功");
}
}

㈩ 單鏈表問題用C語言編寫

用一組地址任意的存儲單元存放線性表中的數據元素。
以元素(數據元素的映象)
+ 指針(指示後繼元素存儲位置)
= 結點
(表示數據元素 或 數據元素的映象)
以「結點的序列」表示線性表
�8�7�8�7 稱作線性鏈表（單鏈表）
單鏈表是一種順序存取的結構，為找第 i 個數據元素，必須先找到第 i-1 個數據元素。
因此，查找第 i 個數據元素的基本操作為：移動指針，比較 j 和 i
單鏈表
1、鏈接存儲方法
鏈接方式存儲的線性表簡稱為鏈表（Linked List）。
鏈表的具體存儲表示為：
① 用一組任意的存儲單元來存放線性表的結點（這組存儲單元既可以是連續的，也可以是不連續的）
② 鏈表中結點的邏輯次序和物理次序不一定相同。為了能正確表示結點間的邏輯關系，在存儲每個結點值的同時，還必須存儲指示其後繼結點的地址（或位置）信息（稱為指針（pointer）或鏈(link)）
注意：
鏈式存儲是最常用的存儲方式之一，它不僅可用來表示線性表，而且可用來表示各種非線性的數據結構。
2、鏈表的結點結構
┌──┬──┐
│data│next│
└──┴──┘
data域--存放結點值的數據域
next域--存放結點的直接後繼的地址（位置）的指針域（鏈域）
注意：
①鏈表通過每個結點的鏈域將線性表的n個結點按其邏輯順序鏈接在一起的。
②每個結點只有一個鏈域的鏈表稱為單鏈表（Single Linked List）。
【例】線性表（bat，cat，eat，fat，hat，jat，lat，mat）的單鏈表示如示意圖
3、頭指針head和終端結點指針域的表示
單鏈表中每個結點的存儲地址是存放在其前趨結點next域中，而開始結點無前趨，故應設頭指針head指向開始結點。
注意：
鏈表由頭指針唯一確定，單鏈表可以用頭指針的名字來命名。
【例】頭指針名是head的鏈表可稱為表head。
終端結點無後繼，故終端結點的指針域為空，即NULL。
4、單鏈表的一般圖示法
由於我們常常只注重結點間的邏輯順序，不關心每個結點的實際位置，可以用箭頭來表示鏈域中的指針，線性表（bat，cat，fat，hat，jat，lat，mat）的單鏈表就可以表示為下圖形式。
5、單鏈表類型描述
typedef char DataType; //假設結點的數據域類型為字元
typedef struct node{ //結點類型定義
DataType data; //結點的數據域
struct node *next;//結點的指針域
}ListNode;
typedef ListNode *LinkList;
ListNode *p;
LinkList head;
注意：
①LinkList和ListNode *是不同名字的同一個指針類型（命名的不同是為了概念上更明確）
②LinkList類型的指針變數head表示它是單鏈表的頭指針
③ListNode *類型的指針變數p表示它是指向某一結點的指針
6、指針變數和結點變數
┌────┬────────────┬─────────────┐
││指針變數│結點變數 │
├────┼────────────┼─────────────┤
│ 定義 │在變數說明部分顯式定義 │在程序執行時，通過標准 │
│ │ │函數malloc生成 │
├────┼────────────┼─────────────┤
│ 取值 │ 非空時，存放某類型結點 │實際存放結點各域內容 │
│ │的地址 │ │
├────┼────────────┼─────────────┤
│操作方式│ 通過指針變數名訪問 │ 通過指針生成、訪問和釋放 │
└────┴────────────┴─────────────┘
①生成結點變數的標准函數
p=( ListNode *)malloc(sizeof(ListNode))；
//函數malloc分配一個類型為ListNode的結點變數的空間,並將其首地址放入指針變數p中
②釋放結點變數空間的標准函數
free(p)；//釋放p所指的結點變數空間
③結點分量的訪問
利用結點變數的名字*p訪問結點分量
方法一：(*p).data和(*p).next
方法二：p-﹥data和p-﹥next
④指針變數p和結點變數*p的關系
指針變數p的值——結點地址
結點變數*p的值——結點內容
(*p).data的值——p指針所指結點的data域的值
(*p).next的值——*p後繼結點的地址
*((*p).next)——*p後繼結點
注意：
① 若指針變數p的值為空（NULL），則它不指向任何結點。此時，若通過*p來訪問結點就意味著訪問一個不存在的變數，從而引起程序的錯誤。
② 有關指針類型的意義和說明方式的詳細解釋
可見，在鏈表中插入結點只需要修改指針。但同時，若要在第 i 個結點之前插入元素，修改的是第 i-1 個結點的指針。
因此，在單鏈表中第 i 個結點之前進行插入的基本操作為:
找到線性表中第i-1個結點，然後修改其指向後繼的指針。
#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define Status inttypedef int ElemType;/*此處利用#define或typedef 將ElemType先作定義*//*此處需補充定義鏈表的結構類型聲明*/LinkList InitList(){LinkList head;</p><p>head=(LinkList)malloc(sizeof(LNode));</p><p>head->next=NULL;</p><p>return head;}void printlist(LinkList L) //這是一個輸出表元的函數{LinkList p;</p><p>p=L->next;</p><p>while(p!=NULL)</p><p>{補充一條語句；</p><p>補充一條語句；}}void CreateListF(LinkList &L , int n ) // 單號的同學用頭插法建表{ /* 補充N條語句，實現用值來建表 */ } void CreateListR(LinkList &L , int n ) // 雙號的同學用尾插法建表{ /* 補充N條語句，實現用值來建表 */ } /*補充一個演算法函數，查找表中值為X元素 */void main(){LinkList y;</p><p>int n;</p><p>printf("請輸入N的值，它代表y中元素個數：");</p><p>scanf("%d",&n);</p><p>printf("\n");</p><p>/*此處調用上面的建表函數*/</p><p>printf("\n");</p><p>printf("這是鏈表y中的元素：");</p><p>/*此處調用上面的函數輸出y表中的元素 */</p><p>printf("\n\n\n");</p><p></p><p>/*此處要補充語句，調用上面的查找表元素的函數*/</p><p></p><p>printf("\n\n\n");</p><p></p><p></p><p>}