指针应用-----链表三

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量70 收藏
点赞数
分类专栏： c研究 文章标签： 指针 链表 单链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/webor2006/article/details/119750838
版权

今天接着对链表进行进一步完善，对于上节中已经实现了对节点的删除操作，这次对这个操作进行升级，符合条件的都可以被删除(通过函数指针来实现)，具体实现如下：

list.c:

#ifndef _LIST_H_
#define _LIST_H_

#include <assert.h>

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

typedef void (*FUNC)(node_t*);
typedef int (*FUNC2)(node_t*);//这个是用来判断是否节点符合条件的

node_t* list_insert_front(node_t* head, int data);

void list_for_each(node_t* head, FUNC f);

node_t* list_free(node_t* head);

node_t* list_get_node(node_t* head, int index);

node_t* list_insert_at(node_t* head, int data, int index);

node_t* list_remove_at(node_t* head, int index);

node_t* list_find(node_t* head, int data, int* ret);

node_t* list_remove_if(node_t* head, FUNC2 f);//根据函数指针实现的符合条件的指针进行删除

#endif /* _LIST_H_ */

list.c:

#include "list.h"
#include <stdlib.h>
#include <stdio.h>

node_t* list_insert_front(node_t* head, int data)
{
    node_t* n = (node_t*)malloc(sizeof(node_t));
    assert(n != NULL);
    n->data = data;
    n->next = NULL;

    if (head == NULL)
        head = n;
    else
    {
        n->next = head;
        head = n;
    }

    return head;
}

void list_for_each(node_t* head, FUNC f)
{
    while (head)
    {
        f(head);
        head = head->next;
    }
}

node_t* list_free(node_t* head)
{
    node_t* tmp;
    while (head)
    {
        tmp = head;
        head = head->next;
        free(tmp);
    }
    return head;
}

node_t* list_get_node(node_t* head, int index)
{
    assert(index >= 0);

    int j = 0;
    while (head && j < index)
    {
        head = head->next;
        j++;
    }
        
    return head;

}

node_t* list_insert_at(node_t* head, int data, int index)
{
    assert(index >= 0);

    if (index == 0)
        return list_insert_front(head, data);

    node_t* p;
    p = list_get_node(head, index - 1);
    if (p == NULL)
    {
        fprintf(stderr, "error insert pos\n");
        exit(EXIT_FAILURE);
    }

    node_t* n = (node_t*)malloc(sizeof(node_t));
    assert(n != NULL);
    n->data = data;
    n->next = NULL;

    n->next = p->next;
    p->next = n;

    return head;
}

node_t* list_remove_at(node_t* head, int index)
{
    assert(index >= 0);
    node_t* n;
    if (index == 0)
    {
        n = head;
        head = head->next;
        free(n);
    }
    else
    {
        node_t* p = list_get_node(head, index - 1);
        if (p == NULL || p->next == NULL)
        {
            fprintf(stderr, "error remove pos\n");
            exit(EXIT_FAILURE);
        }
        n = p->next;
        p->next = n->next;
        free(n);
    }

    return head;
}

node_t* list_find(node_t* head, int data, int* ret)
{
    *ret = -1;
    int i = 0;
    while (head)
    {
        if (head->data == data)
        {
            *ret = i;
            break;
        }
        head = head->next;
        i++;
    }

    return head;
}

node_t* list_remove_if(node_t* head, FUNC2 f)
{
    node_t* prev = NULL;
    node_t* curr = head;
    while (curr)
    {
        node_t* next = curr->next;
        if (f(curr))//符合条件的,则进行删除
        {
            if (prev == NULL)
                head = next;
            else
                prev->next = next;
            free(curr);
        }
        else//不符合条件
            prev = curr;
        curr = next;
    }
    return head;
}

main.c:

#include "list.h"
#include <stdio.h>

void print_node(node_t* n)
{
    printf("data=%d ", n->data);
}

int greater_than_10(node_t* n)//如果结点大小10则为满足条件
{
    return n->data > 10;
}

int main(void)
{
    node_t* head = NULL;
    head = list_insert_front(head, 30);
    head = list_insert_front(head, 20);
    head = list_insert_front(head, 10);

    list_for_each(head, print_node);
    putchar('\n');

    node_t* n = NULL;
    n = list_get_node(head, 1);
    if (n != NULL)
        printf("data = %d\n", n->data);
    else
        printf("not found\n");

    head = list_insert_at(head, 15, 1);
    list_for_each(head, print_node);
    putchar('\n');

    head = list_remove_at(head, 1);
    list_for_each(head, print_node);
    putchar('\n');

    int ret;
    n = list_find(head, 20, &ret);
    if (n != NULL)
        printf("data = %d index = %d\n", n->data, ret);
    else
        printf("not found\n");

    list_remove_if(&head, greater_than_10);
    list_for_each(head, print_node);
    putchar('\n');

    head = list_free(head);
    assert(head == NULL);


    return 0;
}

编译运行：

对于上面这种实现方式，其实我们可以进行优化，也就是一直有提到过的----指针的指针：

下面用它来进行程序的优化:

list.h:

#ifndef _LIST_H_
#define _LIST_H_

#include <assert.h>

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

typedef void (*FUNC)(node_t*);
typedef int (*FUNC2)(node_t*);

node_t* list_insert_front(node_t* head, int data);

void list_for_each(node_t* head, FUNC f);

node_t* list_free(node_t* head);

node_t* list_get_node(node_t* head, int index);

node_t* list_insert_at(node_t* head, int data, int index);

node_t* list_remove_at(node_t* head, int index);

node_t* list_find(node_t* head, int data, int* ret);

void list_remove_if(node_t** head, FUNC2 f);//此时不用返回值了，因为二级指针能改变实参指针的指向

#endif /* _LIST_H_ */

list.c:

void list_remove_if(node_t** head, FUNC2 f)
{
    node_t** curr = head;
    while (*curr)
    {
        node_t* entry = *curr;
        if (f(entry))
        {
            *curr = entry->next;
            free(entry);
        }
        else
            curr = &entry->next;
    }
}

从实现角度来看，这种方式实现起来要简单多了，但是理解起来可能要难一些，但这是比较好的做法，所以接下来，对它进行分解，体现一下二级指针的好处：

下面开始遍历结点，我们假设第一个结点满足条件，第二个结点不满足条件，第三个结点满足条件，来一一来分析删除的流程,这样分析完之后，就对其二级指针的这种实现就会比较清楚了：

删除node1的流程：

 

跳过不满足删除条件node2的流程:

删除node3的流程：

这时再次循环，由于*curr已经指向NULL了，所以循环终止，最后node1和node3就被删除了。通过上面的实现可以发现，利用指针的指针来实现删除时，就不用去判断要删除的节点的前驱是否为NULL了，回顾下之前的实现：

因为指针的指针可以虚拟出一个前驱来，虽说不是真正的前驱，这样就省去了判断，代码也更加精练，好了，理解上面的实现流程之后，下面对其进行测试一下：

main.c:

#include "list.h"
#include <stdio.h>

void print_node(node_t* n)
{
    printf("data=%d ", n->data);
}

int greater_than_10(node_t* n)
{
    return n->data > 10;
}

int main(void)
{
    node_t* head = NULL;
    head = list_insert_front(head, 30);
    head = list_insert_front(head, 20);
    head = list_insert_front(head, 10);

    list_for_each(head, print_node);
    putchar('\n');

    node_t* n = NULL;
    n = list_get_node(head, 1);
    if (n != NULL)
        printf("data = %d\n", n->data);
    else
        printf("not found\n");

    head = list_insert_at(head, 15, 1);
    list_for_each(head, print_node);
    putchar('\n');

    head = list_remove_at(head, 1);
    list_for_each(head, print_node);
    putchar('\n');

    int ret;
    n = list_find(head, 20, &ret);
    if (n != NULL)
        printf("data = %d index = %d\n", n->data, ret);
    else
        printf("not found\n");

    list_remove_if(&head, greater_than_10);//这时就不用再次对head进行赋值了
    list_for_each(head, print_node);
    putchar('\n');

    head = list_free(head);
    assert(head == NULL);


    return 0;
}

编译运行：

接着，将链表的所有能用二级指针的实现都进行统一一下，最终我们的链表程序代码如下：

list.h:

#ifndef _LIST_H_
#define _LIST_H_

#include <assert.h>

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

typedef void (*FUNC)(node_t*);
typedef int (*FUNC2)(node_t*);

void list_insert_front(node_t** head, int data);
void list_for_each(node_t* head, FUNC f);
void list_free(node_t** head);

node_t* list_get_node(node_t* head, int index);
void list_insert_at(node_t** head, int data, int index);
void list_remove_at(node_t** head, int index);
node_t* list_find(node_t* head, int data, int* ret);

//node_t* list_remove_if(node_t* head, FUNC2 f);
void list_remove_if(node_t** head, FUNC2 f);

#endif /* _LIST_H_ */

list.c:

#include "list.h"
#include <stdlib.h>
#include <stdio.h>


void list_insert_front(node_t** head, int data)
{
    node_t* n = (node_t*)malloc(sizeof(node_t));
    assert(n != NULL);
    n->data = data;
    n->next = NULL;

    if (*head == NULL)
        *head = n;
    else
    {
        n->next = *head;
        *head = n;
    }
}

void list_for_each(node_t* head, FUNC f)
{
    while (head)
    {
        f(head);
        head = head->next;
    }
}

void list_free(node_t** head)
{
    node_t* tmp;
    while (*head)
    {
        tmp = *head;
        *head = (*head)->next;
        free(tmp);
    }
}

node_t* list_get_node(node_t* head, int index)
{
    assert(index >= 0);

    int j = 0;
    while (head && j < index)
    {
        head = head->next;
        j++;
    }

/*
    if (j == index)
        return head;
        */

    return head;

}

void list_insert_at(node_t** head, int data, int index)
{
    assert(index >= 0);

    if (index == 0)
        return list_insert_front(head, data);

    node_t* p;
    p = list_get_node(*head, index - 1);
    if (p == NULL)
    {
        fprintf(stderr, "error insert pos\n");
        exit(EXIT_FAILURE);
    }

    node_t* n = (node_t*)malloc(sizeof(node_t));
    assert(n != NULL);
    n->data = data;
    n->next = NULL;

    n->next = p->next;
    p->next = n;
}

void list_remove_at(node_t** head, int index)
{
    assert(index >= 0);
    node_t* n;
    if (index == 0)
    {
        n = *head;
        free(n);
        *head = (*head)->next;
    }
    else
    {
        node_t* p = list_get_node(*head, index - 1);
        if (p == NULL || p->next == NULL)
        {
            fprintf(stderr, "error remove pos\n");
            exit(EXIT_FAILURE);
        }
        n = p->next;
        p->next = n->next;
        free(n);
    }
}

node_t* list_find(node_t* head, int data, int* ret)
{
    *ret = -1;
    int i = 0;
    while (head)
    {
        if (head->data == data)
        {
            *ret = i;
            break;
        }
        head = head->next;
        i++;
    }

    return head;
}

/*
node_t* list_remove_if(node_t* head, FUNC2 f)
{
    node_t* prev = NULL;
    node_t* curr = head;
    while (curr)
    {
        node_t* next = curr->next;
        if (f(curr))
        {
            if (prev == NULL)
                head = next;
            else
                prev->next = next;
            free(curr);
        }
        else
            prev = curr;
        curr = next;
    }
    return head;
}
*/

void list_remove_if(node_t** head, FUNC2 f)
{
    node_t** curr = head;
    while (*curr)
    {
        node_t* entry = *curr;
        if (f(entry))
        {
            *curr = entry->next;
            free(entry);
        }
        else
            curr = &entry->next;
    }
}

main.c:

#include "list.h"
#include <stdio.h>

void print_node(node_t* n)
{
    printf("data=%d ", n->data);
}

int greater_than_10(node_t* n)
{
    return n->data > 10;
}

int main(void)
{
    node_t* head = NULL;
    list_insert_front(&head, 30);
    list_insert_front(&head, 20);
    list_insert_front(&head, 10);

    list_for_each(head, print_node);
    putchar('\n');


    node_t* n = NULL;
    n = list_get_node(head, 1);
    if (n != NULL)
        printf("data = %d\n", n->data);
    else
        printf("not found\n");

    list_insert_at(&head, 15, 1);
    list_for_each(head, print_node);
    putchar('\n');

    list_remove_at(&head, 1);
    list_for_each(head, print_node);
    putchar('\n');

    int ret;
    n = list_find(head, 20, &ret);
    if (n != NULL)
        printf("data = %d index = %d\n", n->data, ret);
    else
        printf("not found\n");

    list_remove_if(&head, greater_than_10);
    list_for_each(head, print_node);
    putchar('\n');

    list_free(&head);
    assert(head == NULL);
    


    return 0;
}

好了，关于链表的实现到此结束，当谈到链表时，如果第一时间你想到的是用一级指针去实现，说明你对C语言的指针理解不是太熟，建议学会用二级指针去解决实际问题，关于C语言相关的探讨，下节再见！

webor2006
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它...学习这些内容有助于深入理解链表数据结构及其在实际问题中的应用。通过分析和实现这些代码，可以提升对数据结构和算法的理解，对于提升编程技能和解决复杂问题的能力非常有帮助。
通用链表操作接口函数
young honker
06-20 1804
list.c/* * *通用链表操作函数定义 ** */ #include #include #include #include "list.h" /*链表初始化*/ void list_init(List *list) { list->head = NULL; list->tail = NULL; list->len = 0; } /*是否为空链表*/ boo
数据结构学习--线性表及其应用--链表
06-25
3. `printlist`：这个函数用于打印链表中的所有节点，从头节点开始，逐个打印每个节点的数据域。 4. `DeleteNode`：这个函数用于删除链表中指定的节点。它首先寻找目标节点，当找到时，修改前一个节点的指针域以跳...
易语言指针链表源码-易语言
06-13
通过研究"易语言指针链表源码"，开发者不仅能加深对链表和指针的理解，还能掌握易语言的编程技巧，为编写更复杂的应用程序打下坚实的基础。在阅读和学习源码的过程中，建议结合具体的编程实践，动手操作，这样能更好...
java链表应用--基于链表实现队列详解（尾指针操作）
08-19
Java链表应用--基于链表实现队列详解（尾指针操作） Java链表应用--基于链表实现队列详解（尾指针操作）是指使用Java语言实现基于链表的队列，并且详细介绍了队列的实现细节，包括链表的改进、链表操作等。 在Java...
西门子S7-200SMART PLC指针使用例程.rar
06-19
3. **操作指针**：使用指针访问和修改数据。例如，可以使用“Indirect”指令读取或写入指针所指向的地址。 4. **指针算术**：可以对指针进行加减操作，以移动到数组的下一个元素或前一个元素。 在“西门子S7-200...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 314
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1112
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 148
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 591
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 347
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 716
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 461
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 406
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 152
新建springboot项目找不到java版本8?
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 468
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 212
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 885
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
uCOS-II信号量集：等待任务链表解析
- **OSFlagWaitList**：指向等待任务链表的指针。当任务因等待信号量集而挂起时，它们会被插入到这个链表中。 - **OSFlagFlags**：表示所有信号量的组合，每个信号量由其中的一位代表。 等待任务链表由OS_FLAG_NODE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

webor2006

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值