linux c语言遍历链表,单链表的基本操作大全之C语言实现

单链表的基本操作大全之C语言实现

1. 单链表的定义

链表是通过一组任意的存储单元来存储线性表中的数据元素，这些存储单元可以是连续的也可以是不连续的。为了建立起数据元素之间的关系，对于每个数据元素除了存放数据元素自身的信息外，还必须有包含的指示该元素直接后继元素存储位置的信息，这两部分信息组成一个结点，即每个结点都有至少包括两个域，一个域存储数据元素信息，称为数据域，另一个域存储直接后继的地址,称为指针域。

typedef struct node{

int data; //数据域

struct node *next; //指针域

}NODE;

当n个元素的线性表通过每个结点的指针域连接成了一条“链子”，我们形象的称之为链表。

2. 建立单链表

建立单链表有两种方法，一种是头插法，一种是尾插法。

在主函数中调用函数时，使用一个NODE *类型的指针接收函数的返回值。

2.1初始化一个链表结点

每次malloc的结点都要初始化，因此写成一个函数。

//初始化一个节点

NODE *initnode(NODE *pnode, int data)

{

pnode = (NODE *)malloc(sizeof(NODE));

pnode->data = data;//初始化数据域

pnode->next = NULL;//初始化指针域为NULL

return pnode;

}

2.2头插法建立链表

在链表的头部插入结点建立单链表，称为“头插法”。

//创建一个新节点(头插法)

NODE *createlink_byhead(NODE *phead, int data)

{

NODE *pnode = initnode(pnode, data);//初始化一个结点

NODE *ptmp = phead;

if(NULL == phead){ //链表为空，直接返回初始化的结点

return pnode;

}else{

phead = pnode; //将新申请的结点插在phead后面，也就是整个链表的最前面

pnode->next = ptmp;

}

return phead;

}

因为每次新结点都会插在链表的头部，则数据读入的顺序和线性表中的逻辑顺序正好相反。

2.3尾插法建立链表

在链表的尾部插入结点建立单链表，简称”尾插法“。

//创建一个链表节点(尾插法)

NODE *createlink_bytail(NODE *phead, int data)

{

NODE *pnode = initnode(pnode, data);//初始化结点

NODE *ptmp = phead;

if(NULL == phead){//当链表为空，直接返回初始化的结点

return pnode;

}else{

while(ptmp->next != NULL){//找到最后一个结点，插在尾部

ptmp = ptmp->next;

}

ptmp->next = pnode;

}

return phead;

}

尾插法读入的数据与线性表中的逻辑顺序相同

3. 链表的长度

//求链表长度

int linklen(NODE *phead)

{

int len =0;//计数器

NODE *ptmp = phead;

while(ptmp != NULL){//遍历链表，计数器加1

len++;

ptmp = ptmp->next;

}

return len;

}

这个算法的时间复杂度为O(n)

4. 按值查找操作

//按值查找

NODE *searchnode(NODE *phead, int key)

{

NODE *ptmp = phead;

if(NULL == phead){ //链表为空，直接返回

return NULL;

}

while(ptmp->data != key && ptmp->next != NULL){//没找到key && 链表没找完

ptmp = ptmp->next; //指针移动

}

if(ptmp->data == key) //找到key，返回该结点地址

return ptmp;

if(ptmp->next == NULL)//没找到，返回空

return NULL;

}

这个算法的时间复杂度为O(n)

5.插入操作

插入操作也分为两种，一种是插在目标值得前面，简称“前插法”，另一种是插在目标值的后面，简称“后插法”。

5.1前插法

//向前插入

NODE *insertnode_bypre(NODE *phead, int data, int key)

{

NODE *pnode = initnode(pnode, data);//初始化插入的结点

NODE *ptmp = phead;

if(NULL == phead){//链表为空，直接返回初始化的结点

return pnode;

}else if(phead->data == key){//处理第一个结点是否为目标结点

phead = pnode;

pnode->next = ptmp;

}else{

while(ptmp->next != NULL && ptmp->next->data != key){//循环遍历，没找完 && 没找到

ptmp = ptmp->next;

}

if(NULL == ptmp->next){//没找到的情况

printf("insert key NOT FOUND\n");

}else{//把新节点插入目标结点的前面

ptmp->next->data == key;

pnode->next = ptmp->next;

ptmp->next = pnode;

}

}

return phead;

}

前插法单独处理了第一个结点，是因为前插法会改变phead的值，而且前插法查找目标结点必须知道目标节点的前驱结点的next值，所以从第二个结点开始处理。

5.2后插法

//向后插入

NODE *insertnode_byback(NODE *phead, int data, int key)

{

NODE *pnode = initnode(pnode, data);//初始化插入的结点

NODE *ptmp = searchnode(phead, key);//查找到目标结点

if(NULL == ptmp){//处理链表为空，或没找到

printf("link is empty or not found key\n");

return phead;

}

if(NULL == ptmp->next){//如果key为最后一个结点

ptmp->next = pnode;

}else{ //将新节点插入在目标结点的后面

pnode->next = ptmp->next;

ptmp->next = pnode;

}

return phead;

}

后插法要单独处理尾结点的情况，因为插入操作不相同。

前插法和后插法的时间复杂度都为O(n)

6.删除操作

//删除节点

NODE *delnode(NODE *phead, int key)

{

NODE *ptmp = phead;

NODE *tmp = NULL;

if(NULL == phead){//处理链表为空的情况

printf("link is empty, del fail\n");

return NULL;

}else if(phead->data == key){//单独处理第一个结点

phead = phead->next;

free(ptmp);

ptmp = NULL;

}else{

while(ptmp->next != NULL && ptmp->next->data != key){ //没找完 && 没找到

ptmp = ptmp->next;

}

if(NULL == ptmp->next){ //没找到

printf("del key NOT FOUND\n");

return phead;

}

if(ptmp->next->data == key){ //找到目标结点删除之

tmp = ptmp->next;

ptmp->next = tmp->next;

free(tmp);

tmp = NULL;

}

}

return phead;

}

单独处理第一个结点还是因为要知道要删除目标结点的前驱结点

删除操作算法时间复杂度为O(n)

7.链表的倒置

链表的倒置算法思路：一次取出原链表中的每一个结点，将其作为第一个结点插入新链表中。

//链表的倒置

NODE *reverselink(NODE *phead)

{

NODE *ptmp = NULL;//创建一个新链

NODE *tmp = NULL;

if(NULL == phead){//处理链表为空

printf("link is empty\n");

return NULL;

}else{

while(phead != NULL){//将旧链上的结点链到新链上

tmp = phead;

phead = phead->next;

tmp->next = ptmp;

ptmp = tmp;

}

}

return ptmp;

}

8.链表的排序(冒泡排序)

//链表排序(冒泡)

NODE *linksort(NODE *phead)

{

NODE *p = NULL; //i

NODE *q = NULL; //j

NODE *r = NULL;

NODE tmp;

for(p = phead; p; p = p->next){

for(q = p->next; q; q = q->next){

if(p->data > q->data){

tmp = *p;//整个结点交换

*p = *q;

*q = tmp;

r = p->next;//将指针换回去

p->next = q->next;

q->next = r;

}

}

}

return phead;

}

冒泡排序的时间复杂度为O(n²)

下面是补充：

1. 递归打印链表

void show_linklist(PNODE *phead)

{

if(phead == NULL){

return;

}else{

printf("%d\t", phead->data);

show_linklist(phead->pnext);

//将此行放在printf的前面则递归打印倒置链表

}

}

2.链表快速排序

PNODE *divide_two_Qsort(PNODE *phead, PNODE *ptail)

{

int key = phead->data;

PNODE *p = phead;

PNODE *q = phead->pnext;

while(q != ptail){

if(q->data < key){

p = p->pnext;

int tmp;

tmp = p->data;

p->data = q->data;

q->data = tmp;

}

q = q->pnext;

}

int tmp = p->data;

p->data = phead->data;

phead->data = tmp;

return p;

}

void quicksort_linklist(PNODE *phead, PNODE *ptail)

{

if(phead != ptail){

PNODE *pmid = divide_two_Qsort(phead, ptail);

quicksort_linklist(phead, pmid);

quicksort_linklist(pmid->pnext, ptail);

}

}

3. 递归计算链表长度

int getlistlen_recursion(PNODE *phead)

{

if(phead == NULL)

return 0;

else

return 1+getlistlen_recursion(phead->pnext);

}

4.反转链表(非递归)

PNODE *invert_linklist(PNODE *phead)

{

if(phead == NULL || phead->pnext == NULL){

return phead;

}else{

PNODE *p = phead;

PNODE *q = NULL;

PNODE *r = NULL;

while(p != NULL){

q = p->pnext;//保存下一个节点

p->pnext = r;//让该节点指向上一个节点

r = p;//上一个节点走到当前节点

p = q;//当前节点走到下一个节点

}

return r;

}

}

5.反转链表(递归)

PNODE *invert_linklist_recursion(PNODE *phead)

{

if(phead == NULL || phead->pnext == NULL){

return phead;

}else{

PNODE *p = phead;//保存头节点

PNODE *q = p->pnext;//保存下一个节点

phead = invert_linklist_recursion(q);//递归到最后一个几点,返回转置后链表的地址

q->pnext = p;//让后面的节点指向前一个节点

p->pnext = NULL;//每次递归返回都赋值为空，最后一次返回将转置后的节点的pnext赋值为空

return phead;

}

}

6.合并两个有序链表(非递归)

PNODE *merge_linklist(PNODE *phead1, PNODE *phead2)

{

if(phead1 == NULL){

return phead2;

}else if(phead2 == NULL){

return phead1;

}

PNODE *phead = NULL;

if(phead1->data < phead2->data){

phead = phead1;

phead1 = phead1->pnext;

}else{

phead = phead2;

phead2 = phead2->pnext;

}//让phead找到最小的头节点

PNODE *pcur = phead;//要比较节点(phead1 或 phead2)的上一个节点

while(phead1 != NULL && phead2 != NULL){

if(phead1->data < phead2->data){

pcur->pnext = phead1;

pcur = phead1;

phead1 = phead1->pnext;

}else{

pcur->pnext = phead2;

pcur = phead2;

phead2 = phead2->pnext;

}

}

pcur->pnext = ((phead1 == NULL) ? phead2 : phead1);

return phead;

}

7.合并两个有序链表(递归)

PNODE *merge_linklist_recursion(PNODE *phead1, PNODE *phead2)

{

if(phead1 == NULL){

return phead2;

}else if(phead2 == NULL){

return phead1;

}

PNODE *phead = NULL;

if(phead1->data < phead2->data){

phead = phead1;

phead->pnext = merge_linklist_recursion(phead1->pnext, phead2);

}else{

phead = phead2;

phead->pnext = merge_linklist_recursion(phead1, phead2->pnext);

}

return phead;

}

8.找到链表中间节点

PNODE *find_midnode(PNODE *phead)

{

if(phead == NULL || phead->pnext == NULL){

return phead;

}

PNODE *p1 = phead;

PNODE *p2 = phead;

while(p2->pnext != NULL){

p1 = p1->pnext;//p1走一步

p2 = p2->pnext;

if(p2->pnext != NULL){

p2 = p2->pnext;//p2走两步

}

}

return p1;

}

9.判断链表是否有环

int is_circularlinklist(PNODE *phead)

{

if(phead == NULL || phead->pnext == NULL){

return 0;

}

PNODE *p1 = phead;

PNODE *p2 = phead;

while(p1 != NULL && p2 != NULL){

p2 = p2->pnext;

if(p1 == p2)

return 1;

p2 = p2->pnext;

p1 = p1->pnext;

}

return 0;

}

10.释放链表

void destory_linklist(PNODE *phead)

{

PNODE *ptmp;

while(phead != NULL){

ptmp = phead;

phead = phead->pnext;

free(ptmp);

ptmp = NULL;

}

}