C语言链表使用

已于 2023-12-05 08:51:05 修改
阅读量72 收藏
点赞数
分类专栏： C语言 文章标签： c语言 链表 数据结构
于 2023-11-24 16:30:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38849487/article/details/134599935
版权

目录

双链表增删改查

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

// 双链表结点的定义
typedef struct DNode{
    int data;
    struct DNode *prev;
    struct DNode *next;
} DNode;

// 创建双链表
DNode *createDoublyLinkedList() {
    int n, i;
    printf("请输入双链表的长度：");
    scanf("%d", &n);

    if (n <= 0) {
        printf("输入的长度无效！\n");
        return NULL;
    }

    DNode *head = NULL;  // 双链表的头结点
    DNode *tail = NULL;  // 双链表的尾结点

    // 创建双链表的结点
    for (i = 0; i < n; i++) {
        int data;
        printf("请输入第 %d 个结点的数据：", i+1);
        scanf("%d", &data);

        DNode *newNode = (DNode*)malloc(sizeof(DNode));
        newNode->data = data;
        newNode->prev = NULL;
        newNode->next = NULL;

        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }

    return head;
}

// 遍历双链表
void traverseDoublyLinkedList(DNode *head) {
    if (head == NULL) {
        printf("双链表为空！\n");
        return;
    }

    DNode *current = head;

    printf("双链表的数据为：");
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 在指定位置插入结点
void insertNode(DNode **head, int position, int data) {
    if (*head == NULL) {
        printf("双链表为空！\n");
        return;
    }

    DNode *current = *head;
    int currentPosition = 1;

    // 找到指定位置的结点
    while (currentPosition < position && current->next != NULL) {
        current = current->next;
        currentPosition++;
    }

    if (currentPosition < position) {
        printf("插入位置无效！\n");
        return;
    }

    // 创建新结点
    DNode *newNode = (DNode*)malloc(sizeof(DNode));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (currentPosition == 1) {
        newNode->next = *head;
        (*head)->prev = newNode;
        *head = newNode;
    } else {
        newNode->next = current;
        newNode->prev = current->prev;
        current->prev->next = newNode;
        current->prev = newNode;
    }

    printf("成功插入结点！\n");
}

// 删除指定位置的结点
void deleteNode(DNode **head, int position) {
    if (*head == NULL) {
        printf("双链表为空！\n");
        return;
    }

    DNode *current = *head;
    int currentPosition = 1;

    // 找到指定位置的结点
    while (currentPosition < position && current != NULL) {
        current = current->next;
        currentPosition++;
    }

    if (current == NULL) {
        printf("删除位置无效！\n");
        return;
    }

    if (currentPosition == 1) {
        *head = (*head)->next;
        if (*head != NULL) {
            (*head)->prev = NULL;
        }
    } else {
        current->prev->next = current->next;
        if (current->next != NULL) {
            current->next->prev = current->prev;
        }
    }

    free(current);
    printf("成功删除结点！\n");
}

// 按值查找结点
DNode *searchNode(DNode *head, int data) {
    if (head == NULL) {
        printf("双链表为空！\n");
        return NULL;
    }

    DNode *current = head;

    // 遍历双链表，找到指定值的结点
    while (current != NULL) {
        if (current->data == data) {
            return current;
        }
        current = current->next;
    }

    printf("未找到指定结点！\n");
    return NULL;
}

//获取指定位置数据
int get_node_value(DNode* head, int pos) {
    if (head == NULL) {  // 判断链表是否为空
        printf("链表为空，无法查找！\n");
        return -1;
    }
    int count = 0;
    DNode* current = head;
    while (current != NULL) {
        if (count == pos) {
            return current->data;  // 找到指定位置的节点，返回节点的值
        }
        count++;
        current = current->next;  // 继续遍历下一个节点
    }
    printf("指定位置不存在节点！\n");  // 遍历完整个链表仍然没有找到节点
    return -1;
}

//查看节点数量
int get_node_count(DNode* head) {
    int count = 0;
    DNode* current = head;

    while (current != NULL) {
        count++;
        current = current->next;
    }

    return count;
}

//打印链表数据
void print_list(DNode* head) {
    DNode* current = head;

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

//从尾部添加数据
DNode* create_node(int data) {
    DNode* newNode = (DNode*)malloc(sizeof(DNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
void append_node(DNode** head, int data) {
    DNode* newNode = create_node(data);

    if (*head == NULL) {
        // 如果链表为空，则将新节点作为头节点
        *head = newNode;
    } else {
        // 找到链表的末尾节点
        DNode* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        // 将新节点添加到末尾
        current->next = newNode;
    }
}

// 释放双链表的内存
void freeDoublyLinkedList(DNode **head) {
    DNode *current = *head;

    while (current != NULL) {
        DNode *temp = current;
        current = current->next;
        free(temp);
    }

    *head = NULL;
    printf("成功释放双链表的内存！\n");
}

int main() {
    DNode *head = NULL;

    // 创建双链表
    head = createDoublyLinkedList();

    // 遍历双链表
    traverseDoublyLinkedList(head);

    // 在指定位置插入结点
    int insertPosition, insertData;
    printf("请输入要插入的位置和数据（以空格分隔）：");
    scanf("%d %d", &insertPosition, &insertData);
    insertNode(&head, insertPosition, insertData);
    traverseDoublyLinkedList(head);

    // 删除指定位置的结点
    int deletePosition;
    printf("请输入要删除的位置：");
    scanf("%d", &deletePosition);
    deleteNode(&head, deletePosition);
    traverseDoublyLinkedList(head);

    // 按值查找结点
    int searchData;
    printf("请输入要查找的值：");
    scanf("%d", &searchData);
    DNode *searchResult = searchNode(head, searchData);
    if (searchResult != NULL) {
        printf("成功找到结点！");
    }
    
     int position;
    printf("请输入要查找的位置：");
    scanf("%d", &position);

    int value = get_node_value(head, position);

    if (value == -1) {
        printf("位置超出链表范围！\n");
    } else {
        printf("位置 %d 的值为：%d\n", position, value);
    }   
    
    int count = get_node_count(head);

    printf("链表中共有 %d 个数据节点\n", count);
    
    append_node(&head, 30);
    print_list(head);
    // 释放双链表的内存
    freeDoublyLinkedList(&head);

    return 0;
}

链表带功能函数

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

typedef struct DNode {
    int data;
    void (*Function)(const char*);
    struct DNode* prev;
    struct DNode* next;
} DNode;

// 创建节点
DNode* createNode(int data, void (*function)(const char*)) {
    DNode* node = (DNode*)malloc(sizeof(DNode));
    node->data = data;
    node->Function = function;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

// 插入节点到链表末尾
void insertNode(DNode** head, DNode* node) {
    if (*head == NULL) {
        *head = node;
    } else {
        DNode* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = node;
        node->prev = current;
    }
}

// 执行链表中的节点功能函数
void executeListFunction(DNode* head, const char* param) {
    DNode* current = head;
    while (current != NULL) {
        if (current->Function != NULL) {
            current->Function(param);
        }
        current = current->next;
    }
}

/*
遍历链表的所有参数
执行对应的功能函数
*/
void executeListFunctions(DNode* head, int searchData, const char* param) {
    DNode* current = head;
    while (current != NULL) {
        if (current->data == searchData && current->Function != NULL) {
            current->Function(param);
        }
        current = current->next;
    }
}
// 示例的功能函数
void function1(const char* param) {
    printf("执行功能函数1，参数：%s\n", param);
}

void function2(const char* param) {
    printf("执行功能函数2，参数：%s\n", param);
}

int main() {
    // 创建节点，并绑定对应功能函数
    DNode* node1 = createNode(1, function1);
    DNode* node2 = createNode(2, function2);

    // 构建链表
    DNode* head = NULL;
    insertNode(&head, node1);
    insertNode(&head, node2);

    // 执行链表中的功能函数
    executeListFunctions(head, 2, "输入字符串参数");

    // 释放内存
    free(node1);
    free(node2);

    return 0;
}

链表函数返回值

要让 executeListFunction 函数返回 Function(param) 函数的返回值，你可以将其结果存储在一个变量中，并在函数结束时将其返回。

以下是修改后的 executeListFunction 函数：

char* executeListFunction(Button* head, const char* buttonname, const char* param) {
    Button* current = head;
    char* result = NULL;
    while (current != NULL) {
        if (strcmp(current->buttonname, buttonname) == 0 && current->Function != NULL) {
            result = current->Function(param);
        }
        current = current->next;
    }
    return result;
}

我们新增了一个变量 result 来存储 Function(param) 函数的返回值，在循环过程中，当找到对应的节点且其功能函数不为空时，我们调用该功能函数并将其返回值赋值给变量 result。最后，在函数结束时将 result 返回。

接下来，你可以在 main 函数中调用 executeListFunction 函数，并将其返回值输出。示例如下：

char* Function(const char* param) {
    // 计算字符串长度
    int len = strlen(param);
    
    // 分配对应长度的内存空间
    char* result = malloc((len + 1) * sizeof(char));
    
    // 将字符串转换为大写字母
    for (int i = 0; i < len; i++) {
        result[i] = toupper(param[i]);
    }
    
    // 在字符串末尾添加终止符
    result[len] = '\0';
    
    // 返回结果字符串
    return result;
}
// 执行链表中特定按钮名称的功能函数，并返回其返回值
char* executeButtonFunction(Button* head, const char* buttonname, const char* param) {
    return executeListFunction(head, buttonname, param);
}

int main() {
    // 创建链表头节点
    Button* head = createNode(1, 1, 1, "Button 1", exampleFunction);
    
    // 在链表尾部插入节点
    Button* node2 = createNode(2, 1, 2, "Button 2", exampleFunction);
    insertNode(&head, node2);
    
    Button* node3 = createNode(3, 2, 1, "Button 3", exampleFunction);
    insertNode(&head, node3);
    
    // 执行特定按钮名称的功能函数，并输出其返回值
    char* result = executeButtonFunction(head, "Button 1", "Hello World");
    printf("Result: %s\n", result);
    
    return 0;
}

在这个示例中，我们修改了 executeButtonFunction 函数，使其调用新增的 executeListFunction 函数，并将其返回值直接返回。在 main 函数中，我们调用 executeButtonFunction 来执行名为 “Button 1” 的按钮的功能函数，并输出其返回值。

追加多个

以下是一个完整的C代码示例，用于创建一个Button节点数组，将其追加到链表中，并进行函数调用。

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

typedef struct Button {
    int id;
    int type;
    int index;
    char label[20];
    void (*callback)();
    struct Button* next;
} Button;

void exampleFunction() {
    printf("Button has been clicked!\n");
}

Button* createButton(int id, int type, int index, char* label, void (*callback)()) {
    Button* button = (Button*)malloc(sizeof(Button));
    button->id = id;
    button->type = type;
    button->index = index;
    strncpy(button->label, label, sizeof(button->label) - 1);
    button->label[sizeof(button->label) - 1] = '\0';
    button->callback = callback;
    button->next = NULL;
    return button;
}

void appendButton(Button** head, Button* newButton) {
    if (*head == NULL) {
        *head = newButton;
    } else {
        Button* curr = *head;
        while (curr->next != NULL) {
            curr = curr->next;
        }
        curr->next = newButton;
    }
}

int main() {
    Button* head = NULL;

    // 创建新的Button节点数组，用于示例
    Button buttons[] = {
        {1, 0, 1, "chuanshumoshi", exampleFunction},
        {2, 0, 2, "chuanshusudu", exampleFunction},
        {3, 0, 3, "duandianxuchu", exampleFunction},
        {4, 0, 4, "shezhi", exampleFunction},
        {5, 0, 5, "example5", exampleFunction}
    };

    int numButtons = sizeof(buttons) / sizeof(buttons[0]);

    // 追加多个Button到链表末尾
    for (int i = 0; i < numButtons; i++) {
        appendButton(&head, &buttons[i]);
    }

    // 遍历链表并调用按钮回调函数
    Button* curr = head;
    while (curr != NULL) {
        curr->callback();
        curr = curr->next;
    }

    return 0;
}

在这个示例中，我们使用了C语言来创建Button结构体，并定义了createButton函数用于创建新的Button节点。我们还定义了appendButton函数来将新的Button节点追加到链表末尾。

在主函数中，我们创建了一个Button指针head来表示链表的头部。然后，通过迭代数组并调用appendButton函数将每个Button节点添加到链表中。

最后，我们遍历链表并调用每个按钮节点的回调函数。

希望这个完整的代码示例对你有所帮助！如有任何疑问，请随时提问。

weixin_38849487
关注
专栏目录
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
c语言链表用处,c语言链表的用途是什么
weixin_39559559的博客
05-21 2119
1、链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。2、例程：/**对链表的综合操作*功能有建立，排序，插入，删除，输出*/#inc...
C语言链表超详解
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
c语言链表示例
shengnan89的博客
05-09 2390
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。 说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该
C语言 链表
m0_68484018的博客
02-27 2847
int data;int data;} Node;上面，我们定义了链表类型，那么我们如何创建链表变量呢，一般采用以下几步：通过调试器可以看到每个数据都是相互连接的。
C语言链表详解
qq_28576837的博客
06-02 4974
C语言链表详解
c语言 链表基本操作
weixin_63178060的博客
08-29 8699
当链表不为空时，则需循环遍历链表，找到链表中最后一个结点，然后将其的next域指向新节点，即cur->next=newnode，此时，不需要将新节点的next域赋值为空，因为在创建结点函数中已将next域赋值为空。在进行头插元素的时候，第一步和第二步不能进行交换，如果先进pre->next=s,此时pre->next指向了s,在进行s->next=pre->next，就会使s->next指向自己本身，无法达到预期效果。如果给定位置正常，则直接将给定位置的next指向，给定位置的next的next。...
C语言链表冒泡排序
m0_74296981的博客
03-10 1519
大一学习C语言的作业，管理系统中需要排序，而且要求用链表，所以来分享两个链表排序的方法。第一种是交换链表的结点，第二种是链表中的数据交换。推荐第二种代码少，效率高。还有很多不足，欢迎各位留言提出。
C语言链表题目（附答案）.docx
08-07
C语言链表题目详解 本资源摘要信息将详细解释C语言链表题目中的知识点，涵盖链表的建立、功能实现、指针、函数、动态结构建立等方面的知识。 一、链表的概念 链表是一种数据结构，它由多个节点组成，每个节点都...
C语言 链表使用示例
06-15
本教程将通过两个经典示例深入讲解如何在C语言中使用链表。 首先，我们来看第一个示例——"Demo1.c"。在这个示例中，我们将创建一个表示学生成绩的链表，每个节点包含学生的ID和分数。为了实现这个链表，我们需要...
学生成绩管理系统课设报告（C语言链表实现）
04-19
本报告将详细介绍如何使用C语言通过链表来实现这样一个系统。 1. **问题描述** - 项目链接：此处应给出项目的源代码仓库或在线平台的链接，方便读者查看完整的代码实现。 - 题目内容与要求：设计一个学生成绩管理...
C语言使用链表实现学生信息管理系统
08-25
C语言使用链表实现学生信息管理系统 该资源主要介绍了使用C语言和链表实现学生信息管理系统的方法，文中提供了详细的示例代码，展示了学生信息管理系统的实现过程。下面是该资源的知识点总结： 1.链表的基本概念：...
c/c++中void定义的空类型指针(void* p)要怎么使用（强制类型转换）以及使用场景(函数指针)
hxj_686的博客
10-12 193
我们先看看下面的代码，p是一个void类型的指针，ch是一个char类型的变量，当我们用p来保存ch的地址时，我们却无法通过*p来对ch的值进行访问，因为char会自动转化为void*类型的指针，也就是空类型指针，void 指针可以指向任意类型的数据，不受数据类型限制，可以在程序中给我们带来一些好处，函数中形参为指针类型时，我们可以将其定义为 void 指针，这样函数就可以接受任意类型的指针。这样，任何类型的指针都可以传入 memcpy 和 memset 中，这也真实地体现了内存操作函数的意义，
【数据结构 | 平衡二叉树】失衡时如何调整
serendipity_hky的博客
10-15 441
可以看这个视频来容易理解：平衡二叉树(AVL树)
数据结构编程实践20讲(Python版)—14邻接矩阵
最新发布
AnFany
10-16 1218
数据结构编程实践20讲(Python版)—14邻接矩阵
Java：数据结构-队列（Queue）
blamep的博客
10-15 366
队列是一种先进先出的数据结构，队列中的元素按照进入的顺序排列，第一个插入的元素最先被移除。
数据结构(7.5_1)——散列查找
m0_65240792的博客
10-15 317
散列表，又称哈希表，是一种数据结构，特点是：数据元素的关键字与其存储地址直接相关散列函数（哈希函数）：Hash(key)=Addr(这里的地址可以是数组下标、索引或内存地址等)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值