单链表操作详解！！！

最新推荐文章于 2024-04-19 17:19:21 发布
最新推荐文章于 2024-04-19 17:19:21 发布
阅读量3.8k 收藏 101
点赞数 19
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43743762/article/details/110134957
版权

文章目录


单链表

学习一种数据结构，要注意：逻辑结构、存储结构、相关操作。

链表最好带一个头结点。

链表的创建一般是在堆上的。

特别注意！！！

  • 进行遍历的时候，结束条件是(p != NULL)，因为循环里面会执行p = p->next;，所以判断时候的p实际上是结点的next指针
  • 寻找前驱结点的时候要判断-1的情况，直接返回H，然后就是一个for (i = 0; i < post; i++)来遍历（从p = H开始），到时候直接返回p！注意是p从头结点指针开始！
  • 尾部插入时，遍历判断的条件是(p->next != NHULL)，这样，p才是指向尾结点的，而不是尾结点的上一个结点指针
  • 删除单个结点的时候要注意，不能截断整个链表，所以要单独一个指针指向删除的结点，先将这个结点移出链表，再进行单独释放
  • 记得在使用完之后释放整个链表，可以在释放的时候打印一下结点信息

1.创建

对于创建一个链表，首先创建一个头结点H。

在堆中创建链表，注意每创建一个节点的时候，对其进行初始化更为严谨，因为这个时候节点还没有与链表建立联系。

创建完成之后，返回这段空间的地址，再往下讲，创建一个空节点就相当于在堆中申请一段listnode大小的空间地址，所以返回的也就是这段地址了。

linklist list_create(void)
{
        linklist p = (linklist)malloc(sizeof(listnode));        
    	if (p == NULL) {
                puts("linklist is NULL!");
                return NULL;
        }           
        p->data = 0;
        p->next = NULL;
        return p;
}

2.遍历

传入链表的头结点，通过头结点将所有节点的数据打印出来。

int list_show(linklist H)
{
        linklist p = H->next;
            
        if (p == NULL) {
                puts("H is NULL");
                return 0;
        }           

        printf("H->");
        for (; p != NULL;) {
                printf("%d->", p->data);
                p = p->next;
        }           
        puts("NULL");

        return 1;
}

注意，在遍历的时候，p = p->next判断，相当于当前判断的p是上一个p

3.插入

在这里插入图片描述

3.1尾部插入

int list_tail_insert(linklist H, data_t val)
{
        int i;

        linklist last = list_create();
        linklist p = H;

        while (p->next != NULL) { //遍历到尾部前一个
                p = p->next;
        }
        p->next = last;  //尾部插入
        last->data = val;
        last->next = NULL;

        return 1;

}

3.2指定位置插入

/*
 *在post位置之前插入新节点，也就是新的节点代替原节点，称为第post节点
 *post的位置从0开始
 * */
int list_post_insert(linklist H, int post, data_t val)
{
	if (H == NULL) {
		puts("H is NULL");
		return -1;
	}
	linklist p = list_prev_find(H, post);
	linklist new = (linklist)malloc(sizeof(listnode));
	if (new == NULL) {
		puts("new node malloc filed");
		return -1;
	}

	new->data = val;
	new->next = p->next;
	p->next = new;

	return 0;
}

4.查找

/*
 *寻找返回post位置的前驱节点
 *post位置从零开始
 * */
linklist list_prev_find(linklist H, int post)
{
	int i;
	linklist p;
	if (H == NULL) {
		puts("H is NULL");
		return NULL;
	}
	if (post == -1) return H;
	if (post < -1) {
		puts("post insert is err");
		return NULL;
	}

	p = H;
	for (i = 0; i < post; i++) {  //找到post前一个节点
		if (p->next == NULL) {
			puts("post insert is err");
			return NULL;
		}
		p = p->next;
	}
	return p;
}

5.删除

在这里插入图片描述

int list_delete(linklist H, int post)
{
	linklist p, q;
	if (H == NULL) {
		puts("H is NULL");
		return -1;
	}

	p = list_prev_find(H, post);
	q = p->next;
	p->next = q->next;

	free(q);
	q = NULL;

	return 0;

}

6.释放

int list_free(linklist H)
{
	if (H == NULL) return -1;
	linklist p = H;

	puts("free:");
	while (H != NULL) {
		p = H;
		printf("%d ", H->data);
		H = H->next;
		free(p);
	}
	puts("");

	return 0;

}

7.排序

细节：

  • 截断链表，p指针指向截断部分
  • 对截断部分排序，每次找出最小的结点
  • 在H后面利用另外一个指针r来执行插入操作

8.倒置、反转

在这里插入图片描述

不允许出现malloc、free！！！

所以要申请一个新的头结点来指向后面的链表，这样就相当于转换为两个链表的插入问题了。

细节：

  • 注意空链表和单个结点的处理，还有当头结点为NULL时的情况
  • 将链表一分为二，新的结点指针指向后面的部分，然后再断开原链表
  • 将后面的链表遍历插入到原链表的0位置（也就是第一个结点的位置）
  • 在插入的时候，对于后半部分的链表，可以借助另外一个指针来遍历

代码：

int list_inversion(linklist H)
{
        linklist p, q;

        if (H == NULL) {
                puts("H si NULL!");
                return -1;
        }
        if ((H->next == NULL) || (H->next->next == NULL)) return 0;
        
        p = H->next->next;     //p指向后半部分
        H->next->next = NULL;  //断开H，只留原始0位置的结点

        while (p != NULL) {
                q = p;
                p = p->next;   //遍历后半部分链表

                q->next = H->next; //始终插入到0位置
                H->next = q;
        }
        return 0;

}

9.求相邻两结点最大值

在这里插入图片描述

细节：

  • 注意H为NULL的特殊情况
  • 只有一个结点、两个结点时的特殊情况
  • 返回的是一个结点指针linklist
  • 注意遍历的结束条件，后一个结点是最后一个结点的时候
  • 要有一个结点指针来存储max结点的地址
  • 在取到地址之后还要做判断

代码：

linklist list_adjmax(linklist H)
{
        linklist p, q, r;
        int tmp = 0, max = 0;

        if (H == NULL) {
                puts("H is NULL!");
                return NULL;
        }

        if ((H->next == NULL) || 
            (H->next->next == NULL) || 
            (H->next->next->next == NULL)) return H->next;

        p = H->next;
        q = p->next;
        r = p;
        while (q != NULL) {              //遍历
                tmp = p->data + q->data; //计算当前值
                r = max>tmp?r:p;         //取较大的结点组的第一个结点的地址
                max = max>tmp?max:tmp;   //更新max
                
                p = p->next;
                q = q->next;
        }
        
        return r;
}

10.合并两有序链表

在这里插入图片描述

细节：

  • 两个链表，由两个结点指针断开
  • 相当于是两个结点指针进行比较，小的插入H1中
  • 插入都是尾部插入，由另外一个结点指针负责插入操作

核心思想是分隔原链表，用一个结点指针来执行插入操作。

代码：

int list_merge(linklist H1, linklist H2)
{
        linklist p, q, r;

        if ((H1 == NULL) || (H2 == NULL)) {
                puts("H is NULL!");
                return -1;
        }

        p = H1->next;
        q = H2->next;
        r = H1;
        H1->next = NULL;
        H2->next = NULL;

        while (p && q) {
                if (p->data < q->data) {
                        r->next = p;
                        p = p->next;
                        r = r->next;
                        r->next = NULL;
                } else {
                        r->next = q;
                        q = q->next;
                        r = r->next;
                        r->next = NULL;
                }
        }
        if (p == NULL) {
                r->next = q;
        } else {
                r->next = p;
        }

        return 0;
}

递归代码：

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    if(l1==NULL)
        return l2;
    if(l2==NULL)
        return l1;
    if(l1->val < l2->val){
        l1->next = mergeTwoLists(l1->next,l2);
        return l1;
    }else{
        l2->next = mergeTwoLists(l1,l2->next);
        return l2;
    }
}

11. 反向递归遍历

给出一个单向不循环链表的头结点，要求不改变链表结构的情况下反向遍历链表中的元素。

思路：递归实现，判断p是否为空，来输出元素。

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

typedef int data_t;
typedef struct node {
    data_t data;
    struct node *next;
}node;

node *list_create();
int list_show(node *H);
node *list_pre_find(node *H, int post);
int list_insert_post(node *H, int post, data_t val);
int list_delete(node *H, int post);
int list_free(node *H);

int list_reverse_show(node *H);


int main(int argc, const char *argv[])
{
    int i, n, num;

    printf("input num size :");
    scanf("%d", &n); 

    node *H = list_create();
    printf("intput data:");
    for (i = 0; i < n; i++) {
        scanf("%d", &num);
        list_insert_post(H, i, num);
    }
    list_show(H);

    /* 功能测试 */
    list_delete(H, 0);
    list_show(H);
    list_insert_post(H, 0, 99);
    list_show(H);

    /* 递归反向遍历，不打印头结点数据，所以传入 H->next */
    list_reverse_show(H->next);
    puts("");

    list_free(H);
    return 0;
}

int list_reverse_show(node *H)
{
    node *p = H;
    if (p != NULL) {
        list_reverse_show(p->next);  //陷入递归，直到链表末尾开始返回，逐步执行printf
        printf("%d ", p->data);
    }

    return 0;
}

node *list_create()
{
    node *p = (node*)malloc(sizeof(node));
    if (NULL == p) {
        printf("malloc filed\n");
        return NULL;
    }

    memset(p, 0, sizeof(node));
    p->next = NULL;

    return p;
}

int list_show(node *H)
{
    if (NULL == H) {
        printf("H is NULL\n");
        return -1;
    }
    node *p = H;

    printf("H->");
    while (p->next != NULL) {
        p = p->next;
        printf("%d->", p->data);
        
    }
    printf("NULL\n");

    return 0;
}

node *list_pre_find(node *H, int post)
{
    if (NULL == H) {
        printf("H is NULL\n");
        return NULL;
    }
    int i;
    node *p;

    p = H;
    for (i = 0; i < post; i++) {
        if (NULL == p) {
            printf("post is over!\n");
            return NULL;
        }
        p = p->next;
    }

    return p;
}

int list_insert_post(node *H, int post, data_t val)
{
    if (NULL == H) {
        printf("H is NULL\n");
        return -1;
    }
    node *p, *q;

    p = list_create();
    p->data = val;

    q = list_pre_find(H, post);
    p->next = q->next;
    q->next = p;

    return 0;
}

int list_delete(node *H, int post)
{
    if (NULL == H) {
        printf("H is NULL\n");
        return -1;
    }
    node *p = list_pre_find(H, post);
    node *q;

    q = p->next;
    p->next = q->next;
    free(q);
    q = NULL;

    return 0;
}

int list_free(node *H)
{
    if (NULL == H) {
        printf("H is NULL\n");
        return -1;
    }

    node *p = H;
    node *q;

    while (p != NULL) {
        q = p;
        p = p->next;
        free(q);
    }
    q = NULL;

    return 0;
}
Aspirant-GQ
关注
  • 19
    点赞
  • 踩
  • 101
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
单链表的常用算法
kxbdys的博客
03-30 5231
一、判断链表是否为空 1、空表：链表中无元素，称为空链表，但头指针和头节点仍然存在。 2、算法思路：判断头结点的指针域是否为空。 int ListEmpty(LinkList L){ //若L为空表，则返回1，否则返回0 if(L->next) //非空 return 0; else return 1; } ...
【数据结构】单链表（超全）
春人.的博客
06-28 9874
上一次我们分享了线性表中的一种结构顺序表，它存在着一些其缺点，比如：在中间位置或者头部进行元素插入或者删除的时候时间复杂度是O(N)效率比较低，并且顺序表在扩容的时候也存在时间和空间上的消耗，由于我们每次都是按照二倍来扩的，那就很有可能会出现扩大了用不完导致空间浪费的现象。这些问题该如何解决呢？那就需要用到今天分享给大家的另一种线性结构链表。
单链表（详解）
最新发布
的博客
04-19 801
链表在物理结构上不一定是连续的在逻辑结构上一定是连续的（可以通过前一个节点的指针找到下一个节点）链表是由一个一个的节点组成的，一个节点存储：指向下一个节点的指针和一个任意类型的数据由此可以知道链表可以通过前一个节点的指针找到下一个节点，各个节点就串联起来了也可以把链表类比成一列火车，火车（链表）有一列列车厢（节点）组成。
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 4968
数据结构深度学习之单链表非常详解解读~~~一万多字详解
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
单链表（一篇带你掌握单链表）
m0_62692838的博客
11-18 1083
数据结构之单链表
C++ 单链表的基本操作(详解)
08-31
在本文中，我们将深入探讨C++实现单链表的基本操作，包括创建、插入、删除节点以及链表的逆序。 1. **概念** 单链表是一种线性数据结构，它的每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的...
单链表详解
12-21
在数组中，插入或删除一个元素都比较繁琐。而链表是一种动态数据结构，可根据需要动态地分配存储单元,用链表则相对容易。但是数组元素的引用比较简单，对于链表中结点数据的存取操作则相对复杂。
C语言单链表实现方法详解
08-27
C语言单链表实现方法详解 单链表是一种基本的数据结构，在C语言中实现单链表可以提高程序的效率和灵活性。本文将详细介绍C语言单链表的实现方法，包括单链表的定义、创建、添加、删除、排序、打印等操作技巧，并...
java 实现单链表逆转详解及实例代码
08-31
此外，代码还记录了逆转操作的耗时，展示了循环逆转相对于递归逆转的性能优势。 总结来说，虽然递归方法在概念上可能更容易理解，但在实际应用中，特别是处理大数据量时，循环逆转单链表的方法更为推荐。这是因为...
C语言 单链表的创建、遍历、释放
m0_74803157的博客
01-06 3187
【代码】C语言 单链表的创建、遍历、释放。
单向链表之释放（C语言实现）
热门推荐
peng_fp的博客
03-19 1万+
链表的创建查看 同遍历链表类似，区别在于p_mov每指向某个节点后都将该节点释放 1、释放前要先保存下一个节点，释放后备份恢复给p_mov,否则释放了当前节点，下一个节点的地址就将失去； 2、依次将所有节点释放后，最后返回NULL（标示释放完毕）。 结构体节点： typedef struct student { int num; //学号 i
数据结构-单链表的实现（删除和释放）day5（复杂操作的实现）day6
楚子航
04-08 3015
一、链表的删除 链表的删除：即实现DeleteLinklist(h, i)， 算法对应的链表结构如图所示。 算法思路：同插入法，先调用函数GetLinklist(h, i-1),找到结点ai的前驱，然后将结点ai删除之。 1.用q指向要被删除的节点，2.将被删除节点前方的箭头直接指向下一个节点。3.释放q指向节点的空间。 二、把整个链表释放 H指针往后走，p指针负责删除，H =NULL时结束。 三、代码 1.linklist.h: 2.linklist.c: 3....
单向链表的创建、链接、遍历、释放
luxus111的博客
01-17 545
1. 创建一个单向链表，并链接节点。
【数据结构学习】单链表的指定位置元素删除、链表的释放
冯宇的博客
02-03 6079
删除指定节点 //删除某个结点 int list_delete(linklist H,int pos){ if(H==NULL){ printf("删除结点失败，链表为空！\n"); return -1; } //获取要删除结点的上一个结点（前驱） listnode *lastnode = list_get(H,pos-1); //当没有前驱，或者该节点不存在的情况下 if(lastnode == NULL || lastnode
单链表的创建，打印，释放，删除指定节点
跑跑跑的博客
12-27 439
*单链表的创建，打印，释放，删除指定节点 // struct cell { //单链表结点结构体定义 int x; struct cell* next; }; 创建单链表 struct cell* build(void) { //新建单链表，并将建好的单链表首结点地址返回 struct cell* head,*tmp,*p; head = tmp = p = NULL; int n; scanf("%d",&n); if(n==0)//输入的数据以0结束 return
单链
weixin_43301647的博客
11-25 993
数据域data：存储数据元素信息的域称为数据域； 指针域：存储直接后继位置的域称为指针域；指针域中存储的信息称为指针或链。 数据域和指针域组成数据元素ai的存储印象，称为节点(Node). 每个节点中包含一个指针域，称为单链表。 链表中第一个节点的存储的位置称为头指针。 链表的最后一个节点指针为“空”。 单链表的第一个节点前附设一个节点，称为头结点。 头结点和头指针的异同 头插入： ...
创建单链表详解之C语言版
sunnyoldboy博客
10-21 6474
链表是用一组任意的存储单元存储数据元素。如果是存储线性表中的元素，则称为线性链表。 链表中的结点地址在内存中可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。因此链表中结点的逻辑顺序和物理顺序不一定相同。 如果链表的结点中只有一个指针域，则该链表称为单链表，这也是常用的线性表的存储模式。 单链表适合于比较频繁的增加或者删除线性表中元素，不需要移动元素。
单链表的清空
hunjiancuo5340的博客
06-15 1万+
转自：https://blog.csdn.net/dan15188387481/article/details/49721749 C语言实现链表之单向链表（四）清空链表 &nbsp; &nbsp; 上一篇文章给出了创建链表的函数，本篇文章将给出清空链表的函数，程序如下。 [cpp] view plain copy ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值