单链表的基础知识总结

已于 2023-05-06 09:58:35 修改
阅读量142 收藏
点赞数
分类专栏： 力扣 文章标签： 算法
于 2023-05-01 10:51:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdxabc1/article/details/130454149
版权

1.简介

  单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。
在这里插入图片描述

结点结构

// Definition for singly-linked list.
struct SinglyListNode {
    int val;
    SinglyListNode *next;
    SinglyListNode(int x) : val(x), next(NULL) {}
};

操作
在这里插入图片描述

2.添加操作

在这里插入图片描述
示例
在这里插入图片描述

在开头添加结点
在这里插入图片描述

3.删除操作

在这里插入图片描述
示例
在这里插入图片描述

删除第一个结点
在这里插入图片描述

4.设计链表

在这里插入图片描述
在这里插入图片描述

方法1:单向链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码

C

//宏定义，用来返回两个参数中的较大值
#define MAX(a, b) ((a) > (b) ? (a) : (b))

//定义了一个名为 MyLinkedList 的结构体，包含一个指向链表头部的指针 head 
//和一个整型成员变量 size，用来记录链表的节点个数。
typedef struct {
    struct ListNode *head;
    int size;
} MyLinkedList;

//创建链表节点的函数，返回一个指向新节点的指针。函数接受一个整型参数 val，
//用来初始化节点的 val 值为 val，next 指针初始化为 NULL。
struct ListNode *ListNodeCreat(int val) {
    struct ListNode * node = (struct ListNode *)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

//创建链表的函数，返回一个指向新链表的指针。函数内部先分配一个 MyLinkedList 结构体的空间，
//将其 head 指针初始化为指向一个 val 为 0 的新节点，size 初始化为 0，然后返回该链表的指针。
MyLinkedList* myLinkedListCreate() {
    MyLinkedList * obj = (MyLinkedList *)malloc(sizeof(MyLinkedList));
    obj->head = ListNodeCreat(0);
    obj->size = 0;
    return obj;
}

//这是获取链表指定位置节点值的函数，接受一个指向链表的指针 obj 和一个整型参数 index，
//返回链表中 index 位置节点的 val 值。如果 index 不合法（小于 0 或大于等于链表的节点数），
//则返回 -1。函数内部先将 cur 指针指向链表头部，然后遍历链表，将 cur 指针依次指向链表中 index 位置的节点，
//最后返回该节点的 val 值。
int myLinkedListGet(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {
        return -1;
    }
    struct ListNode *cur = obj->head;
    for (int i = 0; i <= index; i++) {
        cur = cur->next;
    }
    return cur->val;
}

//这是在链表指定位置添加节点的函数，接受一个指向链表的指针 obj、一个整型参数 index
//（表示要在哪个位置插入节点）和一个整型参数 val（表示新节点的 val 值）。
//如果 index 大于链表节点数，则不插入节点；否则将 index 限制在 [0, size] 范围内，
//然后将该链表的 size 加 1。接着，遍历链表，找到待插入节点的前一个节点 pred，
//并在其后面插入一个新节点 toAdd，将 toAdd 的 next 指针指向 pred 的 next 指向的节点，
//再将 pred 的 next 指针指向 toAdd。
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index > obj->size) {
        return;
    }
    index = MAX(0, index);
    obj->size++;
    struct ListNode *pred = obj->head;
    for (int i = 0; i < index; i++) {
        pred = pred->next;
    }
    struct ListNode *toAdd = ListNodeCreat(val);
    toAdd->next = pred->next;
    pred->next = toAdd;
}

//这是在链表头部插入节点的函数，实际上是调用 myLinkedListAddAtIndex 函数，
//在 index 为 0 的位置插入一个新节点。
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, 0, val);
}

//这是在链表尾部插入节点的函数，实际上是调用 myLinkedListAddAtIndex 函数，
//在 index 为 size 的位置插入一个新节点。
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, obj->size, val);
}


//这是删除链表指定位置节点的函数，接受一个指向链表的指针 obj 和
//一个整型参数 index（表示要删除哪个位置的节点）。如果 index 不合法，
//则直接返回。否则将该链表的 size 减 1，然后遍历链表，找到待删除节点的前一个节点 pred，
//将 pred 的 next 指针指向待删除节点的下一个节点，最后释放待删除节点的空间。
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {
        return;
    }
    obj->size--;
    struct ListNode *pred = obj->head;
    for (int i = 0; i < index; i++) {
        pred = pred->next;
    }
    struct ListNode *p = pred->next;
    pred->next = pred->next->next;
    free(p);
}

//这是释放链表空间的函数，接受一个指向链表的指针 obj。函数内部先定义两个指针 cur 和 tmp，
//将 cur 指向链表头部。然后在循环中，将 tmp 指向 cur，将 cur 指向下一个节点，
//最后释放 tmp 指向的节点空间。循环结束后，释放链表头部节点的空间，最后释放链表的空间。
void myLinkedListFree(MyLinkedList* obj) {
    struct ListNode *cur = NULL, *tmp = NULL;
    for (cur = obj->head; cur;) {
        tmp = cur;
        cur = cur->next;
        free(tmp);
    }
    free(obj);
}

C++

class MyLinkedList {
public:
    MyLinkedList() {
        this->size = 0;
        this->head = new ListNode(0);
    }
    
    int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode *cur = head;
        for (int i = 0; i <= index; i++) {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        index = max(0, index);
        size++;
        ListNode *pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        ListNode *toAdd = new ListNode(val);
        toAdd->next = pred->next;
        pred->next = toAdd;
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        ListNode *pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        ListNode *p = pred->next;
        pred->next = pred->next->next;
        delete p;
    }
private:
    int size;
    ListNode *head;
};

方法2:双向链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
C

#define MAX(a, b) ((a) > (b) ? (a) : (b))

//这个结构体表示双向链表中的一个节点。val 表示节点的值，
//prev 和 next 分别表示指向前一个节点和后一个节点的指针。
typedef struct DLinkListNode {
    int val;
    struct DLinkListNode *prev, *next;
} DLinkListNode;

//这个结构体表示整个双向链表。head 和 tail 分别表示链表的头节点和尾节点，size 表示链表的长度。
typedef struct {
    struct DLinkListNode *head, *tail;
    int size;
} MyLinkedList;


//这个函数用于创建一个新的双向链表节点，并返回该节点的指针。
//在创建节点时，会为节点分配内存空间，并初始化节点的值和指针。
DLinkListNode *dLinkListNodeCreat(int val) {
    DLinkListNode * node = (DLinkListNode *)malloc(sizeof(struct DLinkListNode));
    node->val = val;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

//这个函数用于创建一个新的双向链表，并返回该链表的指针。
//在创建链表时，会为链表分配内存空间，并初始化链表的头节点和尾节点。
//头节点和尾节点的值都为 0，头节点的下一个节点指向尾节点，尾节点的前一个节点指向头节点
MyLinkedList* myLinkedListCreate() {
    MyLinkedList * obj = (MyLinkedList *)malloc(sizeof(MyLinkedList));
    obj->size = 0;
    obj->head = dLinkListNodeCreat(0);
    obj->tail = dLinkListNodeCreat(0);
    obj->head->next = obj->tail;
    obj->tail->prev = obj->head; 
    return obj;
}

//这个函数用于获取双向链表中指定位置的节点的值。如果指定位置超出了链表的范围，则返回 -1。
//在获取节点的值时，需要根据节点的位置判断是从头节点开始还是从尾节点开始遍历。
int myLinkedListGet(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {
        return -1;
    }
    DLinkListNode *curr;
    if (index + 1 < obj->size - index) {
        curr = obj->head;
        for (int i = 0; i <= index; i++) {
            curr = curr->next;
        }
    } else {
        curr = obj->tail;
        for (int i = 0; i < obj->size - index; i++) {
            curr = curr->prev;
        }
    }
    return curr->val;
}

//这个函数用于在双向链表的指定位置插入一个新节点。如果插入位置超出了链表的范围，
//则不进行任何操作。如果插入位置为 0，则表示在链表头部插入新节点；如果插入位置为链表长度，
//则表示在链表尾部插入新节点。在插入节点时，需要根据节点的位置判断是从头节点开始还是从尾节点开始遍历。
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index > obj->size) {
        return;
    }
    index = MAX(0, index);
    DLinkListNode *pred, *succ;
    if (index < obj->size - index) {
        pred = obj->head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        succ = pred->next;
    } else {
        succ = obj->tail;
        for (int i = 0; i < obj->size - index; i++) {
            succ = succ->prev;
        }
        pred = succ->prev;
    }
    obj->size++;
    DLinkListNode *toAdd = dLinkListNodeCreat(val);
    toAdd->prev = pred;
    toAdd->next = succ;
    pred->next = toAdd;
    succ->prev = toAdd;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, 0, val);
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, obj->size, val);
}

//这个函数用于删除双向链表中指定位置的节点。如果指定位置超出了链表的范围，
//则不进行任何操作。在删除节点时，需要根据节点的位置判断是从头节点开始还是从尾节点开始遍历。
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {
        return;
    }
    DLinkListNode *pred, *succ;
    if (index < obj->size - index) {
        pred = obj->head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        succ = pred->next->next;
    } else {
        succ = obj->tail;
        for (int i = 0; i < obj->size - index - 1; i++) {
            succ = succ->prev;
        }
        pred = succ->prev->prev;
    }
    obj->size--;
    DLinkListNode *p = pred->next;
    pred->next = succ;
    succ->prev = pred;
    free(p);
}


//这个函数用于释放双向链表的内存空间。在释放内存时，需要先释放每个节点的内存空间，再释放链表的内存空间。
void myLinkedListFree(MyLinkedList* obj) {
    struct DLinkListNode *cur = NULL, *tmp = NULL;
    for (cur = obj->head; cur;) {
        tmp = cur;
        cur = cur->next;
        free(tmp);
    }
    free(obj);
}
孤芳剑影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【链表】单链表知识总结-内含代码操作及其说明
qq_53830608的博客
01-06 1884
认识链表： 顺序表：逻辑相邻，物理也相邻（例如数组，坐在旁边的一定是舍友） 链表：逻辑相邻，物理不一定相邻（坐在旁边的也不一定是舍友）//不能从第一个数一直遍历到最后一个数 链表就是线性表的链式表述。 因此，链表结点的意义：存放数据+下一个结点的地址 ①结点定义代码如下： typedefintElemType; typedefstructNode { ElemTypedata;//存放数据 structNode* next;// 存放...
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 4591
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 8173
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
【数据结构】——单链表超详细介绍（独家介绍，小白必看！！！）
yakiyakiya的博客
09-06 2万+
今天又是认真更新的一天耶！！一万字的文章，带你吃透单链表！文章内含链表的构建、链表构建时的易错点和注意事项以及链表与顺序表的区别，详细讲解到小白都能学会。
数据结构知识点汇总
热门推荐
Bebr的博客
07-18 13万+
1、用链表表示线性表的优点是（便于插入和删除操作） 2、单链表中，增加头结点的目的是（方便运算的实现） 3、栈和队列的共同特点是（只允许在端点处插入和删除元素） 4、栈通常采用的两种存储结构是（线性存储结构和链表存储结构） 5、队列具有（先进先出）的特征，栈具有（后进先出）的特征。 6、链表（插入和删除不需要移动元素，但是无法随机访问任一元素） 7、循环链表的主要优点是（从表中任一结点...
单链表基础知识整理
TENET_T的博客
09-13 999
单链表知识整理 基础：顺序存储结构与链式存储结构 删除链表结点 链表反转 快慢指针法解决链表相关问题 顺序存储结构与链式存储结构 （首先需要理解线性表的概念） 顺序存储结构 链式存储结构 用一段连续的存储单元存放线性表的数据元素，即逻辑上相邻的，空间上也相邻。 用一组任意的存储单元存放线性表的数据元素，即逻辑上相邻的，空间上不一定相邻。 需要预分配存储空间 不需要预分配存储空间 ...
单链表基本学习
qq_43129608的博客
03-09 208
/** * 单链表 * @author Administrator * */ public class SingleLinkedListDemo { public static void main(String[] args) { // TODO Auto-generated method stub //创建节点 HeroNode heronode1=new HeroNode(1,"宋江","及时雨"); HeroNode ...
公共基础知识点总结.pdf
10-26
这篇资料总结了IT领域的公共基础知识，重点聚焦在算法、数据结构和程序设计方面。首先，算法不是程序，也不是计算方法，而是程序设计的基础。算法必须具备可行性、确定性、有穷性和足够的信息，同时，算法的性能通常...
数据结构与算法基础知识总结.docx
04-01
数据结构与算法是计算机科学的基础，它们涉及到如何有效地组织和操作数据，以便高效地解决问题。...通过深入学习这些基础知识，开发者能够更好地解决各种计算问题，从而提升软件系统的性能和用户体验。
408数据结构知识点总结.docx
07-05
数据结构知识点总结 数据结构是计算机科学的基础，涉及到数据的存储、处理和运算。数据结构知识点总结主要涵盖了数据结构的基本概念、逻辑结构、存储结构、算法和算法评价、线性表等方面。 1. 数据结构的基本概念 ...
数据结构基础知识要点说明.doc
09-28
本文档旨在对数据结构的基础知识进行总结和说明，涵盖数据结构的定义、类型、存储结构、算法、线性表、链表等方面的知识点。 一、数据结构的定义和类型 数据结构是计算机存储、组织数据的方式，可以分为三方面：...
数据结构知识点总结
12-09
数据结构知识点总结 数据结构是计算机科学的基础，它研究的是数据的存储、表示和操作。数据结构知识点总结是数据结构领域的总结，它涵盖了数据结构的基本概念、逻辑结构、存储结构、数据类型、算法等方面。 一、...
【数据结构-D】链表之单链表知识点梳理
weixin_44768184的博客
05-13 1552
【链表】 什么是链表？ 链表是一种用于存储数据集合的数据结构，链表有以下属性： 相连的元素之间通过指针进行链接 最后一个元素的后继指针为NULL 在执行的过程中链表的长度可以增加或者是减少 链表的空间可以按需要进行分配 没有存储空间的浪费，但是链表中的指针需要额外的内存开销 1、我们常见的链表有以下种类 1）单链表、双向链表 2）不带头单链表、带头链表 3）单链表、循环单...
单链表知识点总结
weixin_47651920的博客
10-27 1864
一.什么是链表 1.概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 逻辑上连续是我们想象的连续，并不是真正的连续。 2.链表的分类 单向双向，带头结点不带头结点，循环非循环，组合起来共有8种 二.单链表及单链表的实现 这里我们只实现单链表中的增删改查和其他一些基本的方法，如果单链表弄清了，其他来链表只不过是单链表的延伸。 1.单链表的结构示意图 这里以值域为整形为例，在实际中，值域可以为任意类型 2.图解结点的增删改查 （1）插.
数据结构——线性表——知识点总结
MISAYAONE的博客
05-12 9087
自己看的书，对书上的内容进行总结。 线性表的定义：线性表是具有相同数据类型的n个数据元素的有限序列。n为表长，当n = 0时，为空表。 线性表的公式表示：L = （a1,a2,a3.......an）, a1 为表头元素，an为表尾元素。除了第一个元素，每个元素都有且仅有一个直接前驱，除了最后一个元素，每个元素有且仅有一个直接后继。 线性表的特点：有限个数；逻辑上有顺
力扣2187.完成旅途的最少时间
最新发布
Pisasama的博客
06-12 413
二分答案。
指针和数组
2301_77634163的博客
06-10 458
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
C++的算法：Kosaraju算法与Tarjan算法
全栈工程师Linda的博客
06-10 474
C++的算法：Kosaraju算法与Tarjan算法
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 708
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
单链表基础应用(2)--插入结点c语言
04-19
如果你需要关于单链表基础应用的问题，我可以为你提供一些帮助。这里是一个示例c语言代码，用于在单链表中插入一个新的节点： ``` #include #include struct Node { int data; struct Node* next; }; void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值