C 语言指针与链表的使用

指针有不同的类型，如指向整数的指针（int *）、指向字符的指针（char *）等。指针的类型决定了它所指向的数据的类型。
指针的值是一个内存地址，可以通过取地址运算符（&）获取变量的地址，并将其赋值给指针。例如，int a = 10; int *p = &a;，这里p就是一个指向整数a的指针。

3.指针的运算

指针可以进行一些特定的运算，如加法、减法和比较。指针的加法和减法通常是按照指针所指向的数据类型的大小进行的。例如，如果指针指向一个整数，那么指针加一将指向下一个整数的地址。
指针的比较可以用于判断两个指针是否指向同一个地址或者判断指针是否在某个范围内。

三、链表的基本概念

1.链表的定义与特点

链表是一种动态的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针，链表的起点为头节点，尾节点的指针域为NULL。链表的特点是可以动态地增长和缩小，不需要预先知道数据的数量。
与数组相比，链表的优点是插入和删除元素的操作更加高效，不需要移动大量的数据。缺点是访问特定位置的元素需要遍历链表，时间复杂度较高。

2.链表的类型

单向链表：每个节点只有一个指向下一个节点的指针，只能从链表的头部开始遍历到尾部。
双向链表：每个节点有两个指针，一个指向前一个节点，一个指向下一个节点。双向链表可以在两个方向上进行遍历，并且在某些操作（如删除节点）上更加高效。
循环链表：最后一个节点的指针指向链表的头部，形成一个循环。循环链表可以方便地实现一些特定的算法，如约瑟夫问题。

四、用 C 实现单向链表

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

// 定义链表节点结构
struct ListNode {
    int data;
    struct ListNode* next;
};

// 创建链表节点
struct ListNode* createNode(int data) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表尾部插入节点
void insertAtTail(struct ListNode** head, int data) {
    struct ListNode* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct ListNode* current = *head;
    while (current->next!= NULL) {
        current = current->next;
    }
    current->next = newNode;
}

// 打印链表
void printList(struct ListNode* head) {
    struct ListNode* current = head;
    while (current!= NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 释放链表内存
void freeList(struct ListNode* head) {
    struct ListNode* current = head;
    while (current!= NULL) {
        struct ListNode* next = current->next;
        free(current);
        current = next;
    }
}

以下是对上述代码的分析：

1.定义链表节点结构

struct ListNode定义了链表的节点结构，包含一个整数data用于存储数据，以及一个指向下一个节点的指针next。

2.创建链表节点函数（createNode）

这个函数接受一个整数参数data，用于初始化新节点的数据域。
首先使用malloc动态分配内存来创建一个新的节点。
然后将传入的数据赋值给新节点的data成员，并将next成员初始化为NULL，表示这个节点目前没有下一个节点。
最后返回新创建的节点指针。

3.在链表尾部插入节点函数（insertAtTail）

该函数接受一个链表头指针的指针head（双重指针）和一个整数data作为参数，用于在链表尾部插入一个新节点。
首先创建一个新节点，使用createNode(data)函数。
如果链表为空（即*head为NULL），则将新节点设置为链表的头节点。
如果链表不为空，则遍历链表找到最后一个节点。通过一个while循环，从链表头开始，依次移动current指针，直到current->next为NULL，即找到最后一个节点。
找到最后一个节点后，将其next指针指向新创建的节点，从而将新节点插入到链表尾部。

4.打印链表函数（printList）

这个函数接受一个链表头指针head作为参数，用于打印链表中的所有数据。
从链表头开始，使用一个while循环遍历链表。只要当前节点不为NULL，就打印当前节点的数据，并将current指针移动到下一个节点。

5.释放链表内存函数（freeList）

该函数用于释放链表所占用的内存空间。
从链表头开始，使用一个while循环遍历链表。对于每个节点，先保存下一个节点的指针next，然后释放当前节点的内存，最后将current指针移动到下一个节点。

以下是使用这些函数创建和操作链表的示例：

int main() {
    struct ListNode* head = NULL;
    insertAtTail(&head, 1);
    insertAtTail(&head, 2);
    insertAtTail(&head, 3);

    printList(head);

    freeList(head);
    return 0;
}

在main函数中，首先创建一个空链表（head = NULL），然后通过调用insertAtTail函数向链表中插入三个节点，最后调用printList函数打印链表内容，并调用freeList函数释放链表占用的内存。

五、用C实现双向链表

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

// 定义双向链表节点结构
struct DoublyListNode {
    int data;
    struct DoublyListNode* prev;
    struct DoublyListNode* next;
};

// 创建双向链表节点
struct DoublyListNode* createDoublyNode(int data) {
    struct DoublyListNode* newNode = (struct DoublyListNode*)malloc(sizeof(struct DoublyListNode));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在双向链表尾部插入节点
void insertAtTailDoubly(struct DoublyListNode** head, int data) {
    struct DoublyListNode* newNode = createDoublyNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct DoublyListNode* current = *head;
    while (current->next!= NULL) {
        current = current->next;
    }
    current->next = newNode;
    newNode->prev = current;
}

// 打印双向链表
void printDoublyList(struct DoublyListNode* head) {
    struct DoublyListNode* current = head;
    while (current!= NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 反向打印双向链表
void printDoublyListReverse(struct DoublyListNode* tail) {
    struct DoublyListNode* current = tail;
    while (current!= NULL) {
        printf("%d ", current->data);
        current = current->prev;
    }
    printf("\n");
}

// 释放双向链表内存
void freeDoublyList(struct DoublyListNode* head) {
    struct DoublyListNode* current = head;
    while (current!= NULL) {
        struct DoublyListNode* next = current->next;
        free(current);
        current = next;
    }
}

1.定义双向链表节点结构

struct DoublyListNode定义了双向链表的节点结构，包含一个整数data用于存储数据，以及两个指针prev和next分别指向前一个节点和后一个节点。

2.创建双向链表节点函数（createDoublyNode）

与单向链表的创建节点函数类似，接受一个整数参数data，动态分配内存创建新节点，初始化数据域为data，并将前后指针初始化为NULL。

3.在双向链表尾部插入节点函数（insertAtTailDoubly）

创建新节点后，如果链表为空，直接将新节点设置为链表头。
如果链表不为空，遍历链表找到最后一个节点，然后将新节点插入到最后一个节点之后，并更新新节点和原最后一个节点的前后指针关系。

4.打印双向链表函数（printDoublyList）

从链表头开始，依次遍历并打印每个节点的数据，与单向链表的打印函数类似。

5.反向打印双向链表函数（printDoublyListReverse）

从链表尾开始，通过反向遍历（利用prev指针）并打印每个节点的数据。

6.释放双向链表内存函数（freeDoublyList）

与单向链表的释放内存函数类似，从链表头开始遍历，释放每个节点的内存。

使用双向链表的示例：

int main() {
    struct DoublyListNode* head = NULL;
    insertAtTailDoubly(&head, 1);
    insertAtTailDoubly(&head, 2);
    insertAtTailDoubly(&head, 3);

    printDoublyList(head);
    printDoublyListReverse(head);

    freeDoublyList(head);
    return 0;
}

六、用C实现循环链表

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

// 定义循环链表节点结构
struct CircularListNode {
    int data;
    struct CircularListNode* next;
};

// 创建循环链表节点
struct CircularListNode* createCircularNode(int data) {
    struct CircularListNode* newNode = (struct CircularListNode*)malloc(sizeof(struct CircularListNode));
    newNode->data = data;
    newNode->next = newNode; // 初始时指向自身
    return newNode;
}

// 在循环链表尾部插入节点
void insertAtTailCircular(struct CircularListNode** head, int data) {
    struct CircularListNode* newNode = createCircularNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct CircularListNode* current = *head;
    while (current->next!= *head) {
        current = current->next;
    }
    current->next = newNode;
    newNode->next = *head;
}

// 打印循环链表
void printCircularList(struct CircularListNode* head) {
    if (head == NULL) return;
    struct CircularListNode* current = head;
    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current!= head);
    printf("\n");
}

// 释放循环链表内存
void freeCircularList(struct CircularListNode* head) {
    if (head == NULL) return;
    struct CircularListNode* current = head;
    struct CircularListNode* temp;
    do {
        temp = current;
        current = current->next;
        free(temp);
    } while (current!= head);
}

分析：

1.定义循环链表节点结构

struct CircularListNode定义了循环链表的节点结构，包含一个整数data用于存储数据，以及一个指针next指向下一个节点。

2.创建循环链表节点函数（createCircularNode）

接受一个整数参数data，动态分配内存创建新节点，初始化数据域为data，并将next指针初始化为指向自身，因为单个节点的循环链表就是指向自己。

3.在循环链表尾部插入节点函数（insertAtTailCircular）

创建新节点后，如果链表为空，直接将新节点设置为链表头。
如果链表不为空，遍历链表找到最后一个节点（即当前节点的下一个节点是头节点的节点），然后将新节点插入到最后一个节点之后，并更新新节点的next指针指向链表头。

4.打印循环链表函数（printCircularList）

从链表头开始，使用do-while循环遍历链表，直到再次回到头节点为止，依次打印每个节点的数据。

5.释放循环链表内存函数（freeCircularList）

从链表头开始，使用do-while循环遍历链表，释放每个节点的内存，直到再次回到头节点为止。

使用循环链表的示例：

七、总结

C 指针与链表是 C 语言编程中的重要概念和技术。通过指针，我们可以灵活地操作内存地址，实现高效的数据存储和操作。链表作为一种动态的数据结构，在很多场景下都有广泛的应用。掌握指针与链表的使用方法，对于深入理解 C 语言编程和实现复杂的数据结构至关重要。希望本文能够帮助读者更好地理解和应用 C 指针与链表。

原文地址：https://blog.csdn.net/qq_38072731/article/details/143639635

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：SpringBoot实现的汽车共享业务管理系统
下一篇：cv::intersectConvexConvex返回其中一个输入点集，两个点集不相交

(时序论文阅读)TimeMixer: Decomposable Multiscale Mixing for Time Series Forecasting
来源论文iclr2024论文地址：https://arxiv.org/abs/2405.14616源码地址： https://github.com/kwuking/TimeMixer。
阅读更多2024-11-13
HTML文件中引入jQuery的库文件
HTML文件中引入jQuery的库文件
阅读更多2024-11-13
10款PDF合并工具的使用体验与推荐！！！
在如今的信息洪流中，我们几乎每个人都被淹没在大量的数字文档之中。无论是学生、教师还是职场人士，我们都需要高效地管理和处理这些文档。而PDF文件，凭借其跨平台的稳定性和通用性，成了最常用的文档格式之一。
阅读更多2024-11-13
红日靶机(七)笔记
在 VulnStack7 是由 5 台目标机器组成的三层网络环境，分别为 DMZ 区、第二层网络、第三层网络。涉及到的知识点也是有很多，redis未授权的利用、laravel的历史漏洞、docker逃
阅读更多2024-11-13
【分布式】CAP理论
是分布式系统中的三个基本要求，但根据CAP定理，在分布式系统中，不能同时满足这三者。当网络发生分区时（网络分区通常是不可避免的），系统只能在。每个分布式系统根据具体的业务需求、使用场景和网络环境，都会
阅读更多2024-11-13
【linux】TCP网络编程及Web服务器搭建
默认的情况下，如果一个网络应用程序的一个套接字绑定了一个端口( 占用了 8000 )，这时候，别的套接字就无法使用这个端口( 8000 )端口复用：允许在一个应用程序可以把 n 个套接字绑在一个端
阅读更多2024-11-13
全媒体数字化转型浪潮下半场，有效流量&创新业务是转型成功与否的最好证明
不少传媒企业已经开始积极探索转型之路。通过打造个性IP工作室、重视C端用户服务、深化G端合作等方式，传媒行业正在逐步构建起一个以用户为中心、以数据为驱动、以创新为核心的新型媒体生态。
阅读更多2024-11-13
C++- 基于多设计模式下的同步&异步日志系统
13万字项目带源代码
阅读更多2024-11-13
多路转接之select
表示timeout->tv_sec时间内没有文件描述符的资源准备就绪，就一直阻塞等待，直到等待时间超过timeout->tv_sec才返回。在timeout->tv_sec时间内有文
阅读更多2024-11-13
Android Studio | 修改镜像地址为阿里云镜像地址，启动App
在项目文件的目录下的 settings.gradle.kts 中修改配置，配置中包含插件和依赖项。
阅读更多2024-11-13