链表常见操作

已于 2024-07-05 17:30:40 修改
阅读量704 收藏 13
点赞数 6
文章标签： 链表 数据结构
于 2024-07-04 15:16:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimin_0/article/details/140180219
版权

一、链表

1.1、什么是链表
1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。

2、结点包括两个部分：
（1）存储数据元素的数据域（内存空间）
（2）存储指向下一个结点地址的指针域。

3、相对于线性表顺序结构，操作复杂。

1.2、链表的分类
链表的结构非常多样，以下的情况组合起来就有8种链表结构

（1）单项和双向
在这里插入图片描述

（2）带头和不带头
在这里插入图片描述
（3）循环和不循环
在这里插入图片描述
1.3、链表和数组（顺序表）的比较
（1）数组：使用一块连续的内存空间地址去存放数据，但

例如：
int a[5]={1,2,3,4,5}。突然我想继续加两个数据进去，但是已经定义好的数组不能往后加，只能通过定义新的数组
int b[7]={1,2,3,4,5,6,7}; 这样就相当不方便比较浪费内存资源,对数据的增删不好操作。

（2）链表：使用多个不连续的内存空间去存储数据， 可以 节省内存资源（只有需要存储数据时，才去划分新的空间），对数据的增删比较方便

注意：
1.链式结构在逻辑上是连续的，但在物理上不一定连续
2.现实中的结点一般都是从堆上申请出来的
3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

二、无头单向非循环链表

2.1、无头单向非循环链表的结构
在这里插入图片描述
链表的构成：
链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

typedef struct student
｛
	 int num；
	 int score；
	 char name[20]；
	 struct student *next；//保存下一个节点的地址
 }STU;

链表节点分为两个域

  **数据域**：存放各种实际的数据，如：num、score等

  **指针域**：存放下一节点的首地址，如：next等.

2.1、链表的创建

//创建新节点
STU* creatLinkNode(void)
{
	STU* newnode = (STU*)malloc(sizeof(STU));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}

    memset(newnode, 0, sizeof(STU));
	newnode->next = NULL;

	return newnode;
}

创建一个新节点，用malloc开辟一个链表节点空间，强制转换成链表结构体，将数据域初始化空，将next置为空，并返回新节点。

2.2、单向链表尾插法

//在尾部添加新节点
void addLinkTail(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        /*找到原有链表的最后一个节点，然后在next域指向新节点，
            新节点的next域置为NULL，完成新节点加入链表的操作
        */
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	
        }
 
        p_mov->next = p_new;	
        p_new->next = NULL;
    }
}

单链表的尾插首先需要判断是否是空链表，如果为空就把该节点置为头节点，若不为空，需要找到原链表的最后一个节点，将最后一个节点的next指向新节点，新节点的next置NULL

2.3、单向链表头插法

//单链表的头插法   效率高，简单
void addLinkHead(STU **p_head,STU *p_new)
{
	assert(p_head);
    assert(p_new);

	p_new->next = *p_head;
    *p_head = p_new;
}

头插法相对简单，只需要将新节点插到头结点的前面，并且将头结点指针赋给新节点。

2.4、链表的遍历
第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址
在这里插入图片描述
第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移
在这里插入图片描述
第三步：以此类推，直到节点的指针域为NULL

//打印链表
void printLink(STU *head)
{
    STU *pb = head;
    //判断是否到达链表尾部
    while(pb !=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
}

2.5、单向链表删除尾部节点

//单链表的尾部删出一个节点
void delLinkTail(STU** p_head)
{
	assert(p_head);
	//空
	assert(*p_head);
	// 1个节点
	if ((*p_head)->next == NULL)
	{
		free((*p_head));
		*p_head = NULL;
	}
	else  //两个或者多个节点
	{   //方法一 
		/*STU* pt = *p_head;
		while (pt->next->next)
		{
			pt = pt->next;
		}
		free(pt->next);
		pt->next = NULL;*/
 
		//方法二
		STU* pt = *p_head;  //尾结点
		STU* pf = NULL;     //尾结点的前一个结点
		while (pt->next)
		{
			pf = pt;
			pt = pt->next;
		}
		free(pt);
		pt = NULL;
		pf->next = NULL;
 
	}
}

和尾插法一样，首先先判断链表是否只有一个节点或者没有节点（为空），将会最后一个链表置空，如果超过一个节点，先找到倒数第二个节点，然后置空最后一个节点，将倒数第二个节点的next置空

2.6、单向链表删除头部

 //链表的头删法   效率高，简单
void delLinkHead(STU** p_head)
{
	assert(p_head);
	assert(*p_head);

    /*
    STU* pb = *p_head;
    *p_head = pb->next;
    free(pb);
    pb = NULL;
    */

	STU* pb = (*p_head)->next;
	free(*p_head);
	*p_head = pb;
}

2.7、删除指定节点

如果链表为空，不需要删除 如果删除的是第一个结点，则需要将保存链表首地址的指针保存第一个结点的下一个结点的 地址 如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结 点的后一个结点的地址即可

//删除指定节点pos
void delLinkNode(STU **p_head,STU *pos)
{
    assert(p_head);
    assert(*p_head);
    assert(pos);

    //删除头结点
    if(*p_head == pos)
    {
        STU* pb = (*p_head)->next;
        free(*p_head);
        *p_head = pb;
    }
    else
    {
        STU *pb = *p_head;
        //循环查找要删除的节点
        while(pb->next != pos)
        {
            pb = pb->next;
        }
        //找到要删除的节点
        if(pb->next == pos)
        {
            pb->next = pos->next;
            free(pos);
        }
        else
        {
            printf("节点不存在！\n");
        }
    }
}

//链表结点的删除(按节点内信息)
void delLinkforNum(STU **p_head,int num)
{
    
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head == NULL)//链表为空，不用删
    {
        printf("链表为空，没有您要删的节点");
        return ;
    }
    while(pb->num != num && pb->next !=NULL)//循环找，要删除的节点
    {
        pf=pb;
        pb=pb->next;
    }
    if(pb->num == num)//找到了一个节点的num和num相同
    {
        if(pb == *p_head)//要删除的节点是头节点
        {
            //让保存头结点的指针保存后一个结点的地址
            *p_head = pb->next;
        }
        else
        {
            //前一个结点的指针域保存要删除的后一个结点的地址
            pf->next = pb->next;
        }
 
        //释放空间
        free(pb);
        pb = NULL;
    }
    else//没有找到
    {
        printf("没有您要删除的节点\n");
    }
}

2.8、单向链表的查找

先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下一个结点，如果到达最后一个结点的时候都没有匹配的数据，说明要查找数据不存在

//链表的查找
STU * searLinkForNum(STU *p_head,int num)
{
	assert(p_head);

    //定义的指针变量保存第一个结点的地址
    STU *p_mov = p_head;

    //当没有到达最后一个结点的指针域时循环继续
    while(p_mov != NULL)
    {
        //如果找到是当前结点的数据，则返回当前结点的地址
        if(p_mov->num == num)//找到了
        {
            return p_mov;
        }
        //如果没有找到，则继续对比下一个结点的指针域
        p_mov = p_mov->next;
    }
 
    //当循环结束的时候还没有找到，说明要查找的数据不存在，返回NULL进行标识
    return NULL;//没有找到
}

2.9、单向链表插入一个节点
链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置
在这里插入图片描述
情况（按照从小到大）：
如果链表没有结点，则新插入的就是第一个结点。
如果新插入的结点的数值最小，则作为头结点。
如果新插入的结点的数值在中间位置，则找到前一个，然后插入到他们中间。
如果新插入的结点的数值最大，则插入到最后。

//链表的插入：按照学号的顺序插入
void insertLinkForNum(STU **p_head,STU *p_new)
{
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head == NULL)// 链表为空链表
    {
        *p_head = p_new;
        p_new->next = NULL;
        return ;
    }
    //循环比较要插入的位置
    while((p_new->num >= pb->num)  && (pb->next !=NULL) )
    {
        pf = pb;
        pb = pb->next;
    }
    
    //找到一个节点的num比新来的节点num大，插在pb的前面
    if(p_new->num < pb->num)
    {
        if(pb == *p_head)//找到的节点是头节点，插在最前面
        {
            p_new->next= *p_head;
            *p_head =p_new;
        }
        else
        {
            pf->next=p_new;
            p_new->next = pb;
        }
    }
    else//没有找到pb的num比p_new->num大的节点，插在最后
    {
        pb->next =p_new;
        p_new->next =NULL;
    }
}

2.10、单向链表在指定节点前插入节点

//在指定位置pos前插入一个新节点p_new
void insertLinkFront(STU **p_head,STU *pos,STU *p_new)
{
    assert(p_head);
    assert(*p_head);
    assert(pos);
    assert(p_new);

    //头节点前插入
    if(*p_head == pos)
    {
        p_new->next = *p_head;
        *p_head = p_new;
        return ;
    }
    else
    {
        //在pos前面插入
        STU *pb = *p_head;
        while(pb->next != pos)
        {
            pb=pb->next;
        }
        if(pb->next == pos)   //判断是否找到pos
        {
            p_new->next = pb->next;
            pb->next = p_new;  
        }
        else
        {
            printf("没有找到pos节点\n");
        }
    }
}

2.11、单向链表在指定节点后插入节点

void insertLinkAfter(STU **p_head,STU *pos,STU *p_new)
{
	assert(p_head);
    assert(*p_head);
    assert(pos);
    assert(p_new);

	//要插入的节点是头节点
    if((*p_head) == pos)
    {
        printf("-------------------------------\n");
        p_new->next = (*p_head)->next;
        (*p_head)->next = p_new;
        return ;
    }
    else
    {
        //在pos后面插入,先找到要插入的节点
        #if 0
        STU *pb = (*p_head)->next;
        while(pb != pos)
        {
            pb = pb->next;
        }
        if(pb == pos)   //判断是否找到pos
        {
            p_new->next = pb->next;
            pb->next = p_new;
        }
        else
        {
            printf("没有找到pos节点\n");
        }
        #endif
        
        p_new->next = pos->next;
        pos->next = p_new;
    }
}

2.12、链表节点的释放

重新定义一个指针q，保存p指向节点的地址，然后p后移保存下一个节点的地址，然后释放q对应的节点，以此类推，直到p为NULL为止。

在这里插入图片描述
在这里插入图片描述

//链表的释放
void freeLink(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

三、双向链表

3.1、双向链表的创建
第一步：创建一个节点作为头节点，将两个指针域都保存NULL

在这里插入图片描述

第二步：先找到链表中的最后一个节点，然后让最后一个节点的指针域保存新插入节点的地址，新插入节点的两个指针域，一个保存上一个节点的地址，一个保存NULL

①、节点信息
**

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

②、节点创建

//创建新节点
STU* creatDoubleLinkNode(void)
{
	STU* p_new = (STU*)malloc(sizeof(STU));
	if (p_new == NULL)
	{
		perror("malloc");
		exit(-1);
	}
    memset(p_new, 0, sizeof(STU));
    p_new->front = NULL;
    p_new->next = NULL;
    
	return p_new;
}

3.2、双向链表的遍历

//打印链表
void printDoubleLink(STU *head)
{

    STU *pb = head;
    while(pb->next != NULL) //向后遍历
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
 
    printf("***********************\n");
 
    while(pb != NULL) //向前遍历
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

3.3、双向链表在尾部添加新节点

//在尾部添加新节点
void addDoubleLinkTail(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
    }
    else //第二次及以后加入链表
    {
        /*找到原有链表的最后一个节点，然后在next域指向新节点，
            新节点的next域置为NULL，完成新节点加入链表的操作
        */
        STU *p_mov = *p_head;
        while(p_mov->next != NULL)
        {
            p_mov = p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;			
    }
}

3.4、双向链表在头部添加节点

//链表的头插法   效率高，简单
void addDoubleLinkHead(STU **p_head,STU *p_new)
{
	assert(p_head);
    assert(p_new);
    /*
        1、头结点为空：将新节点赋值给头节点
        2、头节点不为空：则改变头节点的头指针和插入节点的尾指针，最后将新节点赋值给头节点
    */
    if(*p_head != NULL)	
    {
        p_new->next = *p_head;
        (*p_head)->front = p_new;
    }
    *p_head = p_new;
}

3.5、双向链表删除尾节点

//单链表的尾部删出一个节点
void delDoubleLinkTail(STU** p_head)
{
	assert(p_head);
	assert(*p_head);
	// 1个节点
	if ((*p_head)->next == NULL)
	{
		free((*p_head));
		*p_head = NULL;
	}
	else  //两个或者多个节点
	{   
		STU* pt = *p_head;  //尾结点
		STU* pf = NULL;     //保存尾结点的前一个结点
		while (pt->next)
		{
			pf = pt;
			pt = pt->next;
		}
		free(pt);
		pt = NULL;
		pf->next = NULL;	//将尾节点前一个节点的位置针置NULL！！！
	}
}

3.6、双向链表删除头节点

//链表的头删法   效率高，简单
void delDoubleLinkHead(STU** p_head)
{
	assert(p_head);
	assert(*p_head);

	STU* pb = (*p_head)->next;
	free(*p_head);
	*p_head = pb;
}

3.7、双向链表在指定节点后插入一个节点

//在指定位置pos后插入一个新节点p_new
void insertDoubleLinkAfter(STU **p_head,STU *pos,STU *p_new)
{
	assert(p_head);
    assert(*p_head);
    assert(pos);
    assert(p_new);

    p_new->next = pos->next;
    if(pos->next != NULL)   //插入的不是尾节点，需要考虑插入节点后面节点的头指针
        pos->next->front = p_new;
    pos->next = p_new;
    p_new->front = pos;
}

3.8、双向链表在指定节点前插入节点

//在指定位置pos前插入一个新节点p_new
void insertDoubleLinkFront(STU **p_head,STU *pos,STU *p_new)
{
    assert(p_head);
    assert(*p_head);
    assert(pos);
    assert(p_new);
    
    p_new->next = pos;
    if(*p_head != pos)  //插入的节点位置不是头节点，需考虑前后节点的头、尾指针指向
    {
        pos->front->next = p_new; 
        p_new->front = pos->front;
    }
    pos->front = p_new;

    if(*p_head == pos)    //插入的节点的位置为头节点，需要重新给头指针赋值
        *p_head = p_new;
}

3.9、双向链表删除指定节点

//删除指定节点
void delDoubleLinkNode(STU **p_head,STU *pos)
{
    assert(p_head);
    assert(*p_head);
    assert(pos);

    //删除头结点
    if(*p_head == pos)
    {
        STU* pb = (*p_head)->next;
        free(*p_head);
        *p_head = pb;
        //将头节点的头指针置NULL!!!
        (*p_head)->front = NULL;
    }
    else
    {
        if(pos->next == NULL) //删除尾节点
        {
            pos->front->next = NULL;
            free(pos);
            pos = NULL;
        }
        else //删除的不是尾节点
        {
            pos->front->next = pos->next;
            pos->next->front = pos->front;
            free(pos);
            pos = NULL;
        }
    }
}
jimin_0
关注
链表的常见操作
qq_43678418的博客
02-03 274
链表的常见操作
链表的常见操作入门（二）
让你一生残梦的博客
08-10 488
链表的基本已经在上一篇博文中记录了链表的开辟空间，链表的基本遍历。 链表的尾部添加问题：  第一个：使用函数添加元素节点。 struct node { int data; struct node *next; }*head; void add(node *head) { for(int i=1;i&lt;=10;i++){ node *code =...
链表操作
lianghui0811
09-25 460
链表 链表是一个基本数据结构。它由一系列节点组成，每个包含任意数据字段和一个或指向下一个或以前的节点的引用（指针）。        注意：最后一个节点必须值空 比传统阵列的一个链表的主要好处是，挂钩项目的顺序可能会有所不同，在内存中或存储在磁盘上的数据项的顺序，允许项目清单进行不同的顺序遍历。 链表是一个自我指示的数据类型，因为它包含一个指针或链接到另一个相同类型的数据。链表允许在固定时间
链表各类操作详解
ajwh64482的博客
07-07 1007
链表概述　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素...
C语言实现单链表的基本操作
潜龙
04-21 799
内容包括链表的创建，增加、删除节点，链表的逆序、排序和销毁等。 [cpp] view plaincopy #include   #include      typedef struct node   {       int data;       node* pNext;   }Node;      //链表的操作，以有头节点为
Java实现链表的常见操作算法详解
08-25
本篇文章将深入探讨如何在Java中实现单链表的常见操作。 首先，我们需要创建一个表示链表节点的类`Node`。`Node`类通常包含两个属性：`data`用于存储数据，`next`用于存储指向下一个节点的引用。如下所示： ```...
lianbiao.rar_链表基本操作_链表操作
09-24
在链表的头部、尾部或指定位置插入节点是常见的操作。在头部插入节点只需修改头节点，而在尾部插入需要遍历链表找到最后一个节点。例如，在链表头部插入节点的函数可以这样实现： ```c void insertAtHead...
数据结构中链表及常见操作.docx
04-01
链表的常见用途在于处理需要频繁添加、删除和遍历数据的情况，但较少涉及随机检索。例如，在实现动态数组、队列、栈等数据结构时，链表往往是一个很好的选择。 链表与数组的主要区别在于： 1. 存储方式：数组的元素...
数据结构中链表及常见操作.pdf
04-01
链表的常见用途包括需要频繁添加或删除元素的情况，因为这些操作在链表上执行非常高效。然而，如果频繁需要访问特定位置的元素，数组可能更为合适，因为数组提供了随机访问的能力。 链表与数组的主要区别： 1. ...
链表常见操作：逆置(反转)
热门推荐
CCPP Blog
05-20 1万+
链表中的一个很常见的操作是：链表的逆置，也叫链表的反转。 如：1->3->5->7->9 反转后是 9->7->5->3->1
链表的操作
黑脉金的博客
10-16 464
#include #include #include #define maxsize 100 typedef int datatype; using namespace std; datatype x,i; typedef struct seqnode { datatype data; int size; struct seqnode *next; } seqnode,
链表操作（全）
weixin_41440480的博客
11-06 206
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef struct Node{ int data; struct Node * pNext; }NODE,*PNODE;//相当于struct Node NODE,struct Node *PNODE; //函数声明 PNODE cr...
链表使用操作
最新发布
m0_65871698的博客
09-05 289
malloc函数在内存之中动态分配一块size大小的内存空间，它是为链表操作的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值