c语言链式结构包括数据域,数据结构——线性表的链式结构（C语言）

链式存储：以节点的方式存储，节点包括数据域和指针域，指针域的指针指向下一个节点的存储位置，数据的存储可以不连续。头指针作为链表的索引，使链表操作方便，头指针指向头节点，头节点指向第一个节点，以此类推，直到尾节点。

以下是源程序：

函数声明

#ifndef List_H

#define List_H

typedef struct Node *PNode;//定义节点指针

typedef int Item;//定义数据类型

typedef struct Node//定义节点结构

{

Item data;//数据域

PNode next;//指针域

}node;

typedef PNode Position;

typedef PNode List;

/**函数声明**/

/***创建空链表，并返回链表指针***/

List Creat_Empty(List);

/***判断是否为空链表***/

int Is_Empty(List);

/***创建链表，并返回头指针***/

List Make_List();

/*** 链表反转 ***/

List Invert(List);

/***判断是为最后节点***/

int Is_Last(Position);

/***计算链表的长度***/

int Length(List);

/***遍历链表***/

void Traverse_List(List);

/***在链表的某个位置插入数据项***/

void Insert(Item,List,Position);

/***查找链表中对应的数据项，并返回该数据项***/

int Search(Item,List);

/***查找链表中对应的数据项，并返回该数据项的前驱位置***/

Position Search_Previous(Item,List);

/***查找链表中对应的数据项，并返回该数据项的后继位置***/

Position Search_Next(Item,List);

/***获得P的后继节点***/

Position Advance(Position P);

/***删除链表中的某个数据项***/

void Delete(Item,List);

/***删除链表除头节点外的所有节点***/

void Delete_List(List);

/***查找P节点的数据项***/

int Get_Item(Position P);

#endif

函数定义

#include

#include

#include

#include"List.h"

/**函数定义**/

/***创建空链表，并返回链表指针***/

List Creat_Empty(List L)

{

L=(PNode)malloc(sizeof(node));

L->next=NULL;

L->data=0;

return L;

}

/***判断是否为空链表***/

int Is_Empty(List L)

{

return L->next==NULL;

/*

if(NULL==L->next)

return 1;

else

return 0;

*/

}

/***创建链表，并返回链表***/

List Make_List()

{

int val;

PNode pHead =(PNode)malloc(sizeof(node));

PNode pCurrent = pHead;

pCurrent->next = NULL;

if(NULL==pHead)

{

printf("Malloc the list is failed.");

exit(1);

}

printf("Input the first data:");

while(scanf("%d",&val)==1)

{

PNode pNew=(PNode)malloc(sizeof(node));

if(NULL==pNew)

{

printf("Malloc the pNew is failed.");

exit(1);

}

pNew->data=val;

pCurrent->next=pNew;

pNew->next=NULL;

pCurrent=pNew;

printf("Please input the next data:");

}

return pHead;

}

/*** 链表的反转 ***/

List Invert(List Head)

{

PNode middle, trail;

middle = NULL;

PNode temp = Head->next;

while(temp)

{

trail = middle;

middle = temp;

temp = temp->next;

middle->next = trail;

}

Head->next = middle;

return Head;

}

/***判断是为最后节点***/

int Is_Last(Position P)

{

return P->next==NULL;

}

/***计算链表的长度***/

int Length(List L)

{

int len=0;

PNode PCurrent=L->next;

while(NULL!=PCurrent)

{

len++;

PCurrent=PCurrent->next;

}

return len;

}

/***遍历链表***/

void Traverse_List(List L)

{

PNode PCurrent=L->next;

printf("The data of list are:\n");

while(NULL!=PCurrent)

{

printf("%d ",PCurrent->data);

PCurrent=PCurrent->next;

}

printf("\n");

}

/***在链表的某个位置插入数据项***/

void Insert(Item val,List L,Position P)

{

PNode temp;

temp=(PNode)malloc(sizeof(node));

if(NULL==temp)

exit(0);

temp->data=val;

temp->next=P->next;

P->next=temp;

}

/***查找链表中对应的数据项，并返回该数据项***/

int Search(Item val,List L)

{

Position P;

P=L->next;

if(P!=NULL && P->data !=val)

P=P->next;

return P->data;

}

/***查找链表中对应的数据项，并返回该数据项的前驱位置***/

Position Search_Previous(Item val,List L)

{

Position P;

P=L;

if(P->next!=NULL && P->next->data!=val)

P=P->next;

return P;

}

/***查找链表中对应的数据项，并返回该数据项的后继位置***/

Position Search_Next(Item val,List L)

{

Position P;

P=L;

if(P!=NULL && P->data!=val)

P=P->next;

return P;

}

/*

获得位置P后继节点位置

*/

Position Advance(Position P)

{

if(P!=NULL)

return P->next;

}

/***删除链表中的某个数据项***/

void Delete(Item val,List L)

{

Position P, temp;

P=Search_Previous(val,L);

if(!Is_Last(P))

{

temp=P->next;

P->next=temp->next;

free(temp);

}

}

/***删除链表L除头节点外的所有节点***/

void Delete_List(List L)

{

Position P, temp;

P=L->next;

L->next=NULL;

while(P!=NULL)

{

temp=P->next;

free(P);

P=temp;

}

}

/***返回P节点位置的数据项****/

int Get_Item(Position P)

{

if(P!=NULL)

return P->data;

}

测试程序

#include

#include

#include"List.h"

#define NUMBER 5

#define N 3

int main(void)

{

List list;

Position P;

int len,val;

list=NULL;

List L=NULL;

L=Creat_Empty(L);//创建空链表

printf("The empty of list is created.\n");

if(Is_Empty(L))//判断链表是否为空

printf("The list is empty.\n");

list=Make_List();//生成存储有数据项的链表

Traverse_List(list);//遍历该链表

list=Invert(list);//反转链表

Traverse_List(list);//遍历该链表

len=Length(list);//链表的长度

if(!Is_Empty(list))

printf("The length of list is:%d\n",len);

P=list;

Insert(NUMBER,list,P);//在链表中插入数据项

P= Advance(P);//获取P后继节点位置

if(P)

printf("Insert the new data of %d is successed\n",Get_Item(P));

else

printf("Insert the data of %d is failed.\n",NUMBER);

Traverse_List(list);//遍历该链表

val=Search(N,list);//在链表中查找相应的数据项

if(val==N)

printf("Search the data of %d is successed.\n",N);

else

printf("Search the data of %d is failed.\n",N);

Delete(NUMBER,list);//删除数据项

Traverse_List(list);//遍历该链表

Delete_List(list);//摧毁链表

if(Is_Empty(list))

printf("The list is destroied.");

return 0;

}