链表基本操作.docx

链表基本操作.docx

《链表基本操作.docx》由会员分享，可在线阅读，更多相关《链表基本操作.docx（11页珍藏版）》请在冰豆网上搜索。

链表基本操作

#include//标准函数输出库

#include//包含malloc（）函数的函数库

#defineOK1//宏定义OK为1

#defineERROR0//宏定义ERROR为0

structNode{

intele;

structNode*next;

};

/*顺序表的表示方法*/

typedefstruct{

structNode*pData;

intlength;

}LinkedList;

/*顺序表的初始化*/

LinkedList*InitList（LinkedList*L）

{

if（NULL==L）

{

L=（LinkedList*）malloc（sizeof（LinkedList））;//如果链表不存在则开辟空间

if（!

L）

{

printf（"为L申请空间失败!

\n"）;//如果申请失败输出提示语

}

}

L->pData=（structNode*）malloc（sizeof（structNode））;//为指针头结点开辟空间

if（!

L->pData）

{

printf（"为L->pData申请空间失败!

\n"）;

returnNULL;

}else{

L->pData->next=NULL;//头结点指向空

}

L->length=0;//链表长度为0

returnL;

}

/*顺序表的销毁*/

intDestroyList（LinkedList*L）

{

intk=1;

structNode*p=L->pData->next,*q=L->pData;

for（k=1;k<=L->length;k++）

{

free（q）;//释放指针q所指向的空间

q=p;//p指针顺序后移

p=q->next;

}

free（q）;//释放最后结点的内存

L->pData=NULL;//把链表地址置空

return1;

}

/*向第i个位置插入值为x的元素,在第一个位置插入数据时i为1*/

intInsertElem（LinkedList*L,intx,inti）

{

intk=0;

structNode*temp,*head;

temp=（structNode*）malloc（sizeof（structNode））;//为新插入的结点开辟空间

temp->ele=x;//把要插入的值插入到指定位置

temp->next=NULL;//节点指向的位置为空

head=L->pData;//把链表的头指针赋给head

if（!

L->pData||i-1>L->length）

{

printf（"顺序表或是数据位置有问题,不能插入!

"）;

returnERROR;

}

for（k=1;k

{

head=head->next;//找到要插入位置

}

temp->next=head->next;//要插入位置的节点地址赋给temp->next

head->next=temp;//把要插入的节点的指针赋给head->next

temp=NULL;//把temp置空

L->length++;//链表长度加1

returnOK;

}

/*按位置删除:

删除第i个位置上的元素,第一个位置用1表示*/

intDeleteElem（LinkedList*L,inti）

{

intk=0;

structNode*head,*temp;

if（!

L->pData||0==L->length||i>L->length）

{

returnERROR;

}

head=L->pData;

for（k=1;k

{//注意:

若int里面有指针变量的话,应先释放其占用的空间

head=head->next;

}

temp=head->next;//把要删除的位置的地址赋给temp

head->next=head->next->next;//把删除位置的地址赋给它节点的指针域

free（temp）;//把删除的节点的内存释放

temp=NULL;//置空temp

L->length--;//表长度减1

returnOK;

}

/*逆转整个顺序表:

即把整个顺序里面的元素的顺序反转过来*/

intReverseList（LinkedList*L）

{

intk=0;

structNode*p,*q;//结点指针

if（L->length<=1）

{

returnOK;

}

p=L->pData->next->next;//指向第2个元素

q=p->next;//q指向第3个元素

L->pData->next->next=NULL;//将第1个元素的下个指针设为NULL,成为线性表的最后一个元素

for（k=2;k<=L->length-1;k++）//最后一个元素单独处理

{

p->next=L->pData->next;

L->pData->next=p;

p=q;

q=p->next;

}//依次把前一节点的地址赋给后一节点的指针域，后一节点的地址赋给头结点的指针域

p->next=L->pData->next;//把倒数第二个的地址赋给最后一个节点的指针域

L->pData->next=p;//头结点指向最后一个节点

returnOK;

}

/*输出某个数据*/

voidPrintNode（structNodex）

{

printf（"%d",x.ele）;//输出元素的值

}

/*输出顺序表中的每个元素*/

voidPrintList（LinkedList*L）

{

intk=0;

structNode*temp=NULL;

if（!

L->pData||!

L）

{

printf（"顺序表不存在!

\n"）;

return;

}

if（0==L->length）

{

printf（"顺序表是空的!

\n"）;

return;

}

printf（"表中的元素有：

\n"）;

temp=L->pData;//把链表的头指针赋给temp

for（k=1;k<=L->length;k++）

{

temp=temp->next;

PrintNode（*temp）;

}

printf（"\n"）;

}

/*置空表*/

intSetEmpty（LinkedList*L）

{

intk=1;

structNode*p=L->pData->next->next,*q=L->pData->next;//p指向第2个元素，q指向第1个元素

for（k=2;k<=L->length;k++）//依次置空单链表节点

{

free（q）;//释放指针q指向的节点的空间

q=p;//使p指针指向下一节点

p=q->next;//使p指针指向下一节点

}

free（q）;//释放指针q指向的尾节点的空间

L->length=0;

L->pData->next=NULL;//置空指向单链表头节点后一节点的指针

returnOK;//返回值表示操作成功

}

/*求表长*/

intGetListLength（LinkedList*L）

intGetListLength（LinkedList*L）//求表长的函数

{

if（L->pData）//判断单链表是否被分配内存

{

returnL->length;//返回单链表的长度

}

return-1;//单链表没有分配内存时,返回-1

}

/*求前驱*/

intGetPrior（LinkedList*L,intx）

{

structNode*temp=L->pData->next,*prior=L->pData;//temp指向第1个元素,prior指向temp前一个元素

while（temp）//当temp指向的节点不为空时循环

{

if（temp->ele!

=x）//判断指针temp指向的节点的值是否是否等于目标值

{

prior=temp;//使指针prior指向指针temp指向的节点空间

temp=prior->next;//将指针temp指向后一节点

}

else

{

if（prior!

=L->pData）//判断指针prior指向的节点是否是头节点

{//头结点无前驱

returnprior->ele;//返回指针prior指向的节点的值域的值

}

else

{

if（prior==L->pData）//判断指针prior指向的节点是否是头节点

printf（"首节点无前驱,"）;

returnERROR;//返回值表示操作失败

}

}

}

printf（"无此元素,"）;

returnERROR;//返回值表示操作失败

}

/*求后继*/

intGetNext（LinkedList*L,intx）

{

structNode*temp=L->pData->next;//temp指向第1个元素,prior指向temp前一个元素

while（temp）//当temp指向的节点不为空时循环

{

if（temp->ele!

=x）/判断指针temp指向的节点的值是否是否等于目标值

{

temp=temp->next;//使指针temp指向下一节点空间

}

else

{

if（temp->next!

=NULL）//判断指针temp指向的节点是否是尾节点

{

returntemp->next->ele；//返回指针temp指向的节点的后一节点的值域的值

}

else

{

if（temp->next==NULL）//判断指针temp指向的节点是否是尾节点

printf（"尾节点无后继,"）;

returnERROR;//返回值表示操作失败

}

}

}

printf（"无此元素,"）;

returnERROR;//返回值表示操作失败

}

/*按位置查找元素*/

intGetElem（LinkedList*L,inti）

{

intk=1;

structNode*temp=L->pData;//使指针temp指向头结点

if（0>=i||!

L->pData||i>L->length）//判断查找的位置是否合法

{

printf（"单链表不存在或是为空表,"）;

returnERROR;//返回值表示操作失败

}

for（k=1;k

{

temp=temp->next;//使指针temp指向下一节点空间

}

returntemp->ele;//返回指针temp指向的节点的值域的值

}

/*查找元素第一个位置,若无返回-1*/

intGetPosition（LinkedList*L,intx）

{

intk=0;

structNode*p;//定义指向节点的指针

if（!

L->pData）//判断单链表是否被分配内存

{

printf（"单链表不存在!

\n"）;

}

p=L->pData;//将指针p指向头结点

for（k=1;k<=L->length;k++）//循环查找元素位置

{

p=p->next;//使指针p指向下一节点空间

if（p->ele==x）//判断是否与指定值相符

{

returnk;//返回值表示查到的位置

}

}

return-1;//返回值表示单链表中无此元素

}

/*判断是否为空:

1为空,0为非空*/

intIsEmpty（LinkedList*L）

{

if（!

L->pData）//判断单链表是否被分配存储空间

{

printf（"单链表不存在!

\n"）;

}

returnL->length==0;//返回值表示单链表是空的

}

voidmain（）

{

LinkedList*L=NULL;

L=InitList（L）;//初始化顺序表

PrintList（L）;//打印顺序表

InsertElem（L,10,1）;//把元素10插入到第1个位置

InsertElem（L,12,1）;//把元素10插入到第1个位置

InsertElem（L,14,1）;//把元素10插入到第1个位置

PrintList（L）;//打印顺序表

printf（"获取元素10位置：

"）;

printf（"%d\n",GetPosition（L,10））;//获取元素10所在的位置

printf（"获取第三个元素：

"）;

printf（"%d\n",GetElem（L,3））;//获取第i个元素

printf（"删除第二个元素后"）;

DeleteElem（L,2）;

PrintList（L）;//打印顺序表

if（IsEmpty（L））{

printf（"顺序表是空的\n"）;

}else{

printf（"顺序表是非空的\n"）;

}

SetEmpty（L）;//把顺序表置空

PrintList（L）;//打印顺序表

DestroyList（L）;//不要忘了

PrintList（L）;//打印顺序表

if（NULL!

=L）

free（L）;

}