链表内容和习题

已于 2022-08-07 16:16:15 修改
阅读量113 收藏
点赞数
文章标签： 链表 数据结构
于 2022-08-07 16:16:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sst159/article/details/126201644
版权

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）链接的入口节点称为链表的头结点也就是head。

 链表类型：单向链表、双向链表、循环链表

单向链表

双向链表每个节点有两个指针，一个指向前一个节点，一个指向后一个节点

 循环链表

最后一个节点的next指向头结点head

 链表在内存中不连续分布，链表通过  指针   链接  在内存的每个节点

链表的定义

// 单链表
struct ListNode 
{
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
   // ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数   （构造函数可以小不写）
};


//自己定义节点
int main()
{
    ListNode* head = new ListNode(10);
    
    return 0;
}

链表的操作：增删

删

移除链表元素

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while (head != NULL && head->val == val) { // 注意这里不是if
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头结点
        ListNode* cur = head;
        while (cur != NULL && cur->next!= NULL) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        return head;
    }
};
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while (cur->next != NULL) {
            if(cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

 

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int val) {
        if (index > _size || index < 0) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

反转链表

 双指针法：

class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) 
        {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

递归法：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
}; 
class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        ListNode *p;
        for(p=NULL; head; swap(head,p))
            swap(p,head->next);
        return p;
    }
};

链表相交：

 

使用双指针的方法，可以将空间复杂度降至 O(1)O(1)。

只有当链表headA 和headB 都不为空时，两个链表才可能相交。因此首先判断链表 headA 和 headB 是否为空，如果其中至少有一个链表为空，则两个链表一定不相交，返回 null。

当链表 headA 和 headB 都不为空时，创建两个指针pA 和 pB，初始时分别指向两个链表的头节点 headA 和 headB，然后将两个指针依次遍历两个链表的每个节点。具体做法如下：

每步操作需要同时更新指针 pA 和 pB。

如果指针 pA 不为空，则将指针pA 移到下一个节点；如果指针 pB 不为空，则将指针 pB 移到下一个节点。

如果指针 pA 为空，则将指针 pA 移到链表 headB 的头节点；如果指针 pB 为空，则将指针 pB 移到链表 headA 的头节点。

当指针 pA 和 pB 指向同一个节点或者都为空时，返回它们指向的节点或者null。

class Solution 
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        if (headA == nullptr || headB == nullptr) 
        {
            return nullptr;
        }
        ListNode *pA = headA, *pB = headB;
        while (pA != pB) 
        {
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return pA;
    }
};

 求两个链表交点节点的指针。注意，交点不是数值相等，而是指针相等。

求两个链表各自长度，求出差值，让长链表先向后移动差值个位数，然后两个链表一起移动，如果相同则返回。遍历完都不相同返回空

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

环形链表：

使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

 

 

slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z

class Solution 
{
public:
    ListNode *detectCycle(ListNode *head) 
    {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) 
        {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head和相遇点，同时查找直至相遇
            if (slow == fast) 
            {   
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) 
                {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

小小小小小白纸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java算法练习-链表的分化练习题
10-07
java
双链表模拟集合练习题.txt
06-14
java实现双链表模拟集合练习题
链表遍历-习题6和7
m0_65185254的博客
10-07 1588
数据结构
链表经典练习题
2302_81016149的博客
05-01 681
本篇文章到这里就结束了，如果有不理解的题目，可私信或在评论区留下问题，记得一定要练习，这是非常重要的。再强调：大部分题目解法只为了抛砖引玉。希望对大家有所启发。完！
分割链表和回文链表习题
2301_80344616的博客
04-24 1012
/开辟哨兵位的头结点//当cur走完，循环停止//如果小，放入less链表中//如果大于等于，放入greater链表中else//最后把链表合并//解开已经有连好的存在//存储哨兵位前的元素，释放哨兵位的头结点。
C语言之链表练习题
weixin_46305053的博客
12-06 3463
本关需要你设计一个程序，实现单链表的逆置。单链表的逆置分为两种方法：头插法和就地逆置法，这两种方法虽然都能够达到逆置的效果，但还是有着不小的差别。头插法逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。就地逆置法先假定有一个函数，可以将以为头结点的单链表逆序，并返回新的头结点。利用这个函数对问题进行求解：将链表分为当前表头结点和其余部分，递归的过程就是，先将表头结点从链表中拆出来，然后对其余部
Java链表练习题
tdongmu的博客
11-15 412
题目 1.逆序输出链表 1->2->3->4->5 print() 5 4 3 2 1 2.逆置链表 1->2->3->4->5 reverse() 5->4->3->2->1 3.查找单链表中倒数第K个元素 4.合并两个有序的单链表，保证合并后的依然有序 5.不允许遍历链表, 在 pos之前插入 6.找两条相交链表的相交节点 7.判断链表是否有环，有环输出环的入口节点，无环返回null 题目分析与实现 1.使
数据结构——链表以及相关习题
weixin_48796138的博客
07-13 425
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。链表有以下三种特性为什么要重点讲解这一种结构呢?在实现链表之前,我们需要明确链表是由什么构成的,链表是由一个个节点构成的,节点有两个重要的属性 val值,next地址值然后不同的节点有每个节点的地址值串联在一起,像是珍珠由一根线串联在一起,这样一个完整的链表就组成了🍑 代码实现 头插法构造链表 尾插法构造链表 打印链表 寻找节点的位置 在链表对.
链表习题集
cyx6_6的博客
12-16 1650
一一有亿~~~点长
链表简单习题
qq_49425839的博客
08-18 218
链表反转 给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点 链表为空，返回头节点 定义两个结点 pre 为 null ，cur指向头节点 遍历链表时，定义临时结点存放 cur 的下一结点，同时让 cur 指向 pre 因为要向后遍历，pre 向后移到 cur 的位置，cur 移到刚刚定义的临时结点位置 （达到链表反转效果） …（以此循环） 最后因 cur == null 跳出循环， pre 在cur 的前一位，所以返回 pre 即可 class Sol.
【数据结构】链表经典练习题
Dooo_yh的博客
01-01 4021
1.移除单链表元素 2.逆转单链表 3.获取链表的中间结点 4.获取链表中倒数第k个结点 5.合并两个有序单链表 6.单链表一分为二 7.判断链表是否为回文结构
C语言数据结构-----链表类型详解及链表练习题
qq_57425280的博客
11-11 550
之前我讲解了循序表以及单链表，接下来我会在介绍几个不同的链表，并举例相关习题使大家能够更加深入的理解。前期内容如下：链接:链接:链接: [双向链表增删查改的代码实现] 紧张制作中。
链表练习题(修正)1
08-08
4. **显示链表内容**： 函数`display`用于打印链表中所有数据节点的值。给定链表的头指针，这个函数通过迭代遍历整个链表，逐个打印每个节点的数值。 这些练习题涵盖了链表的基本操作，对于学习和理解链表至关重要...
Java算法练习-环形链表插值练习题
10-01
java学习
C语言题库数组，指针，结构体，链表习题
12-28
整理的一些关于C语言的练习题，题目答案都有，需要的可以下载看一下
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1489
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1220
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 415
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1155
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
K - 双向链表练习题
03-25
这是一个经典的链表问题，我们需要先设计链表节点的结构体，并在节点中保留前驱和后继指针，便于双向操作。然后，我们可以定义一个链表类，在该类中定义一些方法来实现链表的基本操作。 本题需要实现的方法包括： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值