2.链表

最新推荐文章于 2023-08-20 16:00:00 发布
最新推荐文章于 2023-08-20 16:00:00 发布
阅读量112 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 指针 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nodd_le/article/details/115306567
版权

C语言数据结构基础——链表

链表是线性表的一种，每个节点里存储了数据域和指针域，其中指针域中存储指向下一个节点的指针。相比顺序表，链表在插入和删除操作上更方便。链表有很多不同类型：单向链表、双向链表、循环链表等。

链表定义

我们把链表想象成火车，火车头便是链表的表头，每节车厢就是链表的元素，车厢里载的人和物就是元素的数据域，连接车厢的部件就是元素的指针。

由此，我们可以得出链表的一个特点：元素之间前后依赖，串联而成。相比于数据域成片的顺序表链表的元素不能随机访问。链表中元素前后连接是单一的，即元素前面和后面不会出现多个元素相连的情况。

链表基本操作的实现
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct Node {
    int data;
    struct Node *next;
} Node;
typedef struct List {
    Node *head;  // 头指针地址
    int length;  // 链表长度
} List;
/*
* 链表初始化操作
* @return 链表指针
* */
List *init_list() {
    List *l = (List *)malloc(sizeof(List));
    l->head = NULL;
    l->length = 0;
    return l;
}
/*
* 插入操作，时间复杂度O(n)
* @param l 待操作链表
* @param ind 待插入坐标
* @param val 待插入元素值
* */
int insert(List *l, int ind, int val) {
    if(l == NULL) return 0;                     // 链表未初始化
    if(ind < 0 || ind > l->length) return 0;    // 判断坐标是否合法
    Node *node = (Node *)malloc(sizeof(Node));  // 新建一个链表结点
    node->data = val;
    node->next = NULL;
    if(ind == 0) {                              // 坐标为0，需要更新头指针
        node->next = l->head;
        l->head = node;
    }else {
        Node *p = l->head;                      // 新建一个临时指针指向链表头
        while(--ind) p = p->next;               // 移动指针到ind前一个位置
        node->next = p->next;                   // 将当前结点的指针指向原本ind位置
        p->next = node;                         // ind的前一个结点指向当前新结点
    }
    l->length++;                                // 更新链表长度
    return 1;
}
/*
* 删除操作 时间复杂度O(n)
* @param l待操作链表
* @param ind 待删除元素的坐标
* */
int delete(List *l, int ind) {
    if(l == NULL) return 0;                     // 链表未初始化
    if(ind < 0 || ind >= l->length) return 0;    // 判断坐标是否合法
    Node *delete_node;
    if(ind == 0) {                              // 坐标为0，需要更新头指针
        delete_node = l->head;
        l->head = l->head->next;
    }else {
        Node *p = l->head;                      // 新建一个临时指针指向链表头
        while(--ind) p = p->next;               // 移动指针到ind前一个位置
        delete_node = p->next;
        p->next = delete_node->next;            // ind前一个位置的指针指向ind后一个位置
    }
    free(delete_node);                                 // 释放指定结点
    l->length--;                                // 更新链表长度
    return 1;
}
/**
* 反转操作 时间复杂度 O(n)
* @param l待操作链表
* */
void reverse(List *l) {
    if(l == NULL || l->length < 2) return;      // 链表未初始化或者，长度在1以内不需要反转
    Node *p = l->head;                          // 定义一个结点指向链表头
    l->head = NULL;                             // 将头结点都链表上拆下来
    while(p) {                                  // 头结点指向当前结点的后两个结点
        Node *temp = p->next;                   // 定义一个临时结点指向当前结点的下一个
        p->next = l->head;                      // 将当前结点从链表上取下来
        l->head = p;                            // 当前结点更新为头结点
        p = temp;                               // 移动当前指向
    }
    return;
}
/*
* 清理链表 时间复杂度 O(n)
* @param l待操作链表
* **/
void clear(List *l) {
    if(l == NULL) return;                       // 判断链表是否已经初始化
    Node *p = l->head;                          // 定义一个结点指向链表头
    while(p) {
        Node *temp = p->next;                   // 定义临时结点指向后一个结点
        free(p);                                // 释放当前结点
        p = temp;                               // 更新当前链表
    }
    free(l);
}
/*
* 查询链表 时间复杂度 O(n)
* @param l待操作链表
* @param val 待查找的值
* */
int search(List *l, int val) {
    if(l == NULL) return -1;                    // 判断链表是否已经初始化
    Node *p = l->head;                          // 定义一个结点指向链表头
    int i = 0;
    while(p) {
        if(p->data == val) return i;
        p = p->next;
        i++;
    }
    return -1;
}
/*
* 遍历链表 时间复杂度 O(n)
* @param l待操作链表
* **/
void output(List *l) {
    if(l == NULL) return;                       // 判断链表是否已经初始化
    Node *p = l->head;                          // 定义一个结点指向链表头
    printf("List:[");
    while(p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("]\n");
}
int main() {
    srand(time(0));
    #define MAX_OP 20
    List *l = init_list();
    for(int i = 0; i < MAX_OP; i++) {
        int op = rand() % 4;
        int val = rand() % 100;
        int ind = rand() % (l->length + 3);
        if(op) {
            int res = insert(l, ind, val);
            printf("insert %d at %d to List = %d\n", val, ind, res);
        }else {
            int res = delete(l, ind);
            printf("erase a item at %d from List = %d\n", ind, res);
        }
        output(l), printf("\n");
    }
    reverse(l);
    output(l);
    clear(l);
    #undef MAX_OP
    return 0;
}
循环链表的基本操作

循环链表，相比单链表，循环链表不同的是它将最后一个结点的指针指向了头结点，这样的结构使得链表更加灵活方便。循环链表里没有空指针，所以在判断结束条件时，不再是判断指针是否为空，而是判断指针是否等于某固定指针。另外，在单链表里，一个节点只能访问到它后面的结点，而在循环链表里它可以访问到所有的结点。

/*************************************************************************
  > File Name: 2.linklist_loop.c
  > Author: 陈杰
  > Mail: 15193162746@163.com
  > Created Time: 2021年03月29日 星期一 11时31分10秒
  > 循环链表的基本操作
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
/*链表节点定义*/
typedef struct Node {
    int data;
    struct Node *next;
} Node;
/*链表定义*/
typedef struct List{
    Node *head;
    int length;
} List;
/*
* 初始化链表
* */
List *init() {
    List *l = (List *)malloc(sizeof(List));     // 动态申请指针域
    l->head = NULL;                             // 默认链表指针指向空
    l->length = 0;
}
/*
* 插入元素 时间复杂度O(n)
* @param l: 要操作的链表指针
* @param ind: 要插入的下标点
* @param val: 要插入元素的值
* */
int insert(List *l, int ind, int val) {
    if(l == NULL) return 0;                     // 判断链表是否已经初始化
    if(ind < 0 || ind > l->length) return 0;    // 判断要插入的下标是否合法
    Node *node = (Node *)malloc(sizeof(Node));  // 动态申请一个节点，并初始化
    node->data = val;
    node->next = NULL;
    /*判断链表是否为空*/
    if(l->head == NULL) {
        l->head = node;
        l->head->next = node;
    }else {
        Node *p = l->head;
        int index = ind;
        while(index--) p = p->next;             // 将链表移动到指定位置的前一个下标
        node->next = p->next;
        p->next = node;
        if(ind == l->length) l->head = node;    // 若插入坐标为最后一位，更新头节点
    }
    l->length++;
    return 1;
}
/*
* 删除元素 时间复杂度为O(n)
* @param l: 要操作的链表指针
* @param ind: 要删除的下标点
* **/
int delete(List *l, int ind) {
    if(l == NULL) return 0;                     // 判断链表是否已经初始化
    if(ind < 0 || ind >= l->length) return 0;   // 判断要插入的下标是否合法
    Node *p = l->head, *delete_node;
    if(l->length == 1) {
        delete_node = l->head;
        l->head = NULL;
    }else {
        while(ind--) p = p->next;               // 将链表移动到指定位置的前一个下标
        delete_node = p->next;                  // 记录要删除的节点地址
        p->next = delete_node->next;
        if(delete_node == l->head) l->head = delete_node->next;
    }
    free(delete_node);
    l->length--;
    return 1;
}
/*
* 反转链表 时间复杂度O(n)
* @param l: 要操作的链表指针
* **/
void reverse(List *l) {
    if(l == NULL || l->length < 2) return;      // 链表为空或者长度小于2什么都不用做
    Node *p,*head = l->head;                    // 定义一个节点指向链表尾部
    Node *begin = p = head->next;
    l->head = NULL;                             // 把头节点从循环链表上拆下来
    Node *temp = NULL;
    while(p != head){                           // 从头到位循环到尾节点前一个
        temp = p->next;
        p->next = l->head;
        l->head = p;
        p = temp;
    }
    // 链表变成一个单链表及一个节点head。
    head->next = l->head;                       // temp等于前头结点，当前的尾节点
    begin->next = head;
    l->head = begin;
}
/*
* 清理链表 时间复杂度O(n)
* @param l: 要操作的链表指针
* **/
void clear(List *l) {
    if(l == NULL) return;                       // 判断链表是否已经初始化
    if(l->head == NULL) {
        free(l);
        return;
    }
    Node *p,*head = l->head;                    // 定义一个节点指向链表头
    p = head->next;
    while(p != head){
        Node *temp = p->next;
        free(p);
        p = temp;
    }
    free(head);
    free(l);
}
/*
* 打印链表 时间复杂度O(n)
* @param l: 要操作的链表指针
* **/
void output(List *l) {
    if(l == NULL || l->head == NULL) return;    // 判断链表是否已经初始化,且链表不能为空
    Node *p,*head = l->head;                    // 定义一个节点指向链表头
    p = head->next;
    printf("List:[");
    while(p != head){
        printf("%d ", p->data);
        p = p->next;
    }
    printf("%d]\n", head->data);
}
int main() {
    srand(time(0));
    #define MAX_OP 20
    List *l = init();
    for(int i = 0; i < MAX_OP; i++) {
        int op = rand() % 4;
        int val = rand() % 100;
        int ind = rand() % (l->length + 1);
        if(op) {
            int res = insert(l, ind, val);
            printf("insert %d at %d to List = %d\n", val, ind, res);
        }else {
            int res = delete(l, ind);
            printf("erase a item at %d from List = %d\n", ind, res);
        }
        output(l), printf("\n");
    }
    reverse(l);
    output(l);
    clear(l);
    #undef MAX_OP
    return 0;
}
双链表的基本操作

双向链表也叫双链表。单链表里的指针域只记录了结点的下一个结点，也就是后继结点，而双向链表的指针域还记录了结点的上一个结点，也就是前驱结点。有了这样的结构，我们可以从头结点遍历到尾结点，也可以从尾结点遍历到头结点了。

双向链表操作与单项链表相似，唯一需要注意的就是操作时头尾指针均需要变化。

/*************************************************************************
  > File Name: 2.linklist_binary.c
  > Author: 陈杰
  > Mail: 15193162746@163.com
  > Created Time: 2021年03月29日 星期一 09时15分34秒
  > 链表的基本操作
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct Node {
    int data;
    struct Node *next;
    struct Node *prov;
} Node;
typedef struct List {
    Node *head;  // 头指针地址
    int length;  // 链表长度
} List;
/*
* 链表初始化操作
* @return 链表指针
* */
List *init_list() {
    List *l = (List *)malloc(sizeof(List));
    l->head = NULL;
    l->length = 0;
    return l;
}
/*
* 插入操作，时间复杂度O(n)
* @param l 待操作链表
* @param ind 待插入坐标
* @param val 待插入元素值
* */
int insert(List *l, int ind, int val) {
    if(l == NULL) return 0;
    if(ind < 0 || ind > l->length) return 0;
    Node *node = (Node *)malloc(sizeof(Node));
    node->data = val;
    node->next = NULL;
    node->prov = NULL;                          // 初始化prov
    if(ind == 0) {
        node->next = l->head;
        if(l->head) l->head->prov = node;       // 判断头结点是否为空，否则更新头结点的prov
        l->head = node;
    }else {
        Node *p = l->head;
        while(--ind) p = p->next;
        node->prov = p;
        node->next = p->next;
        if(p->next) p->next->prov = node;       // 判断下标后的点是否为空，否则更新后面点的prov值
        p->next = node;
    }
    l->length++;
    return 1;
}
/*
* 删除操作 时间复杂度O(n)
* @param l待操作链表
* @param ind 待删除元素的坐标
* */
int delete(List *l, int ind) {
    if(l == NULL) return 0;
    if(ind < 0 || ind >= l->length) return 0;
    Node *delete_node;
    if(ind == 0) {
        delete_node = l->head;
        l->head = l->head->next;
        if(l->head) l->head->prov = NULL;       // 判断头结点是否为空，否则更新头结点的prov
    }else {
        Node *p = l->head;
        while(--ind) p = p->next;
        delete_node = p->next;
        p->next = delete_node->next;
        if(delete_node->next) delete_node->next->prov = p;  // 判断删除节点后面是否有点，有的话更改其prov
    }
    free(delete_node);
    l->length--;
    return 1;
}
/**
* 反向打印 时间复杂度 O(2n)
* @param l待操作链表
* */
void reverse(List *l) {
    if(l == NULL) return;
    Node *p = l->head;
    while(p && p->next)  p = p->next;           // 将指针移至最后一个节点
    printf("reList:[");
    while(p) {
        printf("%d ", p->data);
        p = p->prov;
    }
    printf("]\n");
}
/*
* 清理链表 时间复杂度 O(n)
* @param l待操作链表
* **/
void clear(List *l) {
    if(l == NULL) return;
    Node *p = l->head;
    while(p) {
        Node *temp = p->next;
        free(p);
        p = temp;
    }
    free(l);
}
/*
* 查询链表 时间复杂度 O(n)
* @param l待操作链表
* @param val 待查找的值
* */
int search(List *l, int val) {
    if(l == NULL) return -1;
    Node *p = l->head;
    int i = 0;
    while(p) {
        if(p->data == val) return i;
        p = p->next;
        i++;
    }
    return -1;
}
/*
* 遍历链表 时间复杂度 O(n)
* @param l待操作链表
* **/
void output(List *l) {
    if(l == NULL) return; 
    Node *p = l->head;
    printf("List:[");
    while(p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("]\n");
}
int main() {
    srand(time(0));
    #define MAX_OP 20
    List *l = init_list();
    for(int i = 0; i < MAX_OP; i++) {
        int op = rand() % 4;
        int val = rand() % 100;
        int ind = rand() % (l->length + 1);
        if(op) {
            int res = insert(l, ind, val);
            printf("insert %d at %d to List = %d\n", val, ind, res);
        }else {
            int res = delete(l, ind);
            printf("erase a item at %d from List = %d\n", ind, res);
        }
        output(l), printf("\n");
    }
    reverse(l);
    output(l);
    clear(l);
    #undef MAX_OP
    return 0;
}
nodd_le
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2. 链表-一根绳上的蚂蚱1
08-03
链表定义链表（Linked List）是一种线性表数据结构，使用非连续的内存空间，存储相同或者不同类型的元素，但不要求元素大小相等使用链表存储不同的元素视具体语
一、基础数据结构-1.链表-2.静态链表
最新发布
01-17
一、基础数据结构-1.链表-2.静态链表
数据结构之链表详解
m0_56440500的博客
08-20 3079
链表是一种常见的数据结构，它可以用来存储一组数据，并支持快速的插入和删除操作。相比于数组，链表的大小可以动态地增加或减小，因此在某些场景下更加灵活和高效。本文将详细介绍链表的定义、基本操作和应用场景，希望能够帮助读者深入理解链表的原理和实现。链表是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点可以在内存中任意位置，因此它们不必按照顺序连续存储。链表的头节点是第一个节点，尾节点是最后一个节点，它们分别由指向第一个节点和最后一个节点的指针来表示。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8963
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【C语言数据结构】双链表详解（带头双向循环链表）
dhgiuyawhiudwqha的博客
04-05 1820
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
【数据结构】C语言实现双链表
weixin_44104992的博客
07-31 461
C语言实现双链表
数据结构之双链表（c语言附完整代码)
m0_62795460的博客
11-04 2084
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。声明双链表typedef struct DNode //定义双链表结点类型 {//数据域 struct DNode * prior;//指向前驱结点 struct DNode * next;//指向后继结点 } DLinkNode;注意：本文章讨论的双链表是带头结点的双链表。
c++程序链表类设计.cpp
06-30
请设计一个链表类，实现链表的初始化、插入、删除和打印操作。 节点的定义如下： typedef int elementType; typedef struct node { elementType data; node* next; } LList, *PList; 链表类的定义及要求...
4. 链表-最简单的递归结构1
08-03
答案隐藏在了题干中: 小青蛙每次能跳1阶或者2阶如果小青蛙第一次跳了1阶，那么还剩下n-1阶如果小青蛙第一次跳了2阶，那么还剩下n-2阶实现递归的关键就在于如何
程序员面试金典 – 面试题 02.05. 链表求和
12-22
给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，并用链表形式返回结果。 示例： 输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295...
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 6459
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
C语言-双向链表
qq_64831425的博客
02-25 829
C语言-双链表
c语言简单实现双向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-18 2570
c语言最简单实现双向链表
四、链表、双向链表、循环链表
ThisEqualThis的博客
05-21 282
链表 链表存储有序的元素集合，不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。如下图： 要想访问链表中间的一个元素，需要从起点（表头）开始迭代列表直到找到所需的元素。 创建链表类： ...
链表概述
dongyanxia1000的专栏
05-01 423
1、数组是一种顺序存储的数据结构，逻辑上相邻的两个元素在物理上也是相邻的。      每个元素占用的内存相同，可以通过下标访问。      如果要增加或删除一个元素，需要移动大量元素。但可以快速访问数据。 2、链表是一种链接（链式）存储的数据结构，逻辑上相邻的两个元素在物理上一般是不相邻的。      相邻元素之间的访问必须通过指针实现。      如果要访问链表中的一个元素，需要从第一
数据结构与算法—链表
weixin_49757069的博客
05-22 322
链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。 链表与数组的对比： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。在数组中，我们可以直接访问任何元位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 class Node { constructor(element) { this.el
链表知识点总结
Lookdrama的博客
10-27 1012
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每一个结构均含有元素和指向该元素后继结构的指针。
数据结构——双链表（C语言详述通用双链表）
weixin_42645653的博客
04-15 3124
  该文是根据李先静先生的书籍《系统程序员成长计划》中的双链表的1.4拥抱变化的示例程序进行分析，作为小白，相对来说写的比较详细，故篇幅较长。   依据李先生的双链表的示例，希望能够学习到一二。主要是想加深一下印象。也希望对其他人有所帮助，难免会存在一些错误的理解和笔误，希望看文章的朋友能够指出。   为便于阅读，函数的出场次序与源程序有所出路。   程序源码整体可从：系统程序员成长计划 ——学习篇3：双链表处获取。 概念   了解双链表之前应先对单链表有所了解，单链表虽能100%解决逻辑关系为“一对一”数
用C或C++编程编译运行实现一个链表，链表主函数功能菜单需要实现以下功能1.创建链表2.链表的按位查找3.链表的按位插入和按位删除4.实现两个有序链表的合并操作
10-28
2. 定义链表的头指针，并初始化为空。 3. 实现创建链表的函数，通过循环输入数据并创建节点，将节点插入链表中。 4. 实现按位查找链表节点的函数，通过循环遍历链表，找到指定位置的节点并返回。 5. 实现按位插入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值