【数据结构】详解11道链表OJ题（万字详解）

已于 2024-09-08 18:19:41 修改
阅读量1k 收藏 10
点赞数 15
分类专栏： 数据结构 文章标签： 链表 数据结构 算法
于 2022-08-11 19:49:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68651804/article/details/126210029
版权

文章目录

1. 移除链表元素

OJ链接

题目要求：
在这里插入图片描述
解析：

  1. 法一：
  • 两个指针：cur和prev。cur用来遍历，寻找需要被删除的结点；prev指向cur结点的前一个结点，用于删除,prev->next = cur->next，free(cur)(只有当头结点不为空且不需要删除时，才会用到prev指针)。
  • 特殊情况1：链表为空，直接返回head。
  • 特殊情况2：链表所有结点都需要被删除，（用不上指针prev）。
//code-1:
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* cur = head;
    //1.特殊情况，链表为空
    if(cur == NULL)
        return head;
    
    //2.特殊情况，链表中的所有结点的val都等于目标值，需全部删除
    while(cur && cur->val == val)
    {
        struct ListNode* del = cur;
        cur = cur->next;
        free(del);
        //del是局部变量，不需要再置空
    }
    //更新头结点
    head = cur;
    //出2的循环时，要么cur为空，要么cur->val!=val

    //3.常规情况
    struct ListNode* prev = cur;
    //prev->val!=val
    if(prev)
    {
        
        cur = prev->next;
        //如果要删除，就删除cur结点
        while(cur)
        {
            //需要删除
            if(cur->val == val)
            {
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }
            else
            {
                prev = cur;
                cur = cur->next;
            }
        }
    }

    return head;
}

算法复杂度： 时间复杂度O(n)，空间复杂度O(1)。
在这里插入图片描述

  1. 法二（推荐）：
    与法一类似，但代码简化许多。
  • 两个指针：cur和prev。
  • 直接用cur遍历。如果cur指向的结点不需要删除，让prev指向当前cur指向的结点，再让cur后移。
  • 如果cur指向的结点需要删除，分情况。
    • 若当前cur指向的结点为头结点，则让head后移，然后删除当前cur结点。再更新cur指针。
    • 若当前cur指向的结点不为头结点，则按常规情况删除，prev->next = cur->next,free(cur)。再更新cur。
//code-2
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* cur = head;
    struct ListNode* prev = NULL;//指向要删除结点的上一个结点
    while(cur)
    {
        //需要删除当前结点
        if(cur->val == val)
        {
            //需要删除的结点是头结点
            if(cur == head)
            {
                head = head->next;
                free(cur);
                cur = head;
            }
            else//删除非头节点
            {
                //常规情况的删除
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }
        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }

    return head;
}

算法复杂度： 时间复杂度O(n)，空间复杂度O(1)。
在这里插入图片描述

  1. 法三：
  • 创建一个新链表。
  • 用新链表存储不需要删除的结点（将原链表中不需要删除的结点链接到新链表中），删除原链表中需要删除的结点。
  • 返回新链表。
//code-1: 不带哨兵位结点
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* newHead, *tail;
    newHead = tail = NULL;

    struct ListNode* cur = head;

    while(cur)
    {
        if(cur->val != val)
        {
            if(tail == NULL)
            {
                newHead = tail = cur;
            }
            else
            {
                tail->next = cur;
                tail = tail->next;
            }
            cur = cur->next;
        }
        else
        {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);//局部变量，不需要再置为空
        }
    }
    //新链表结尾置为空
    if(tail)//防止解引用空指针
        tail->next = NULL;
    return newHead;
}

在这里插入图片描述

//code-2: 带哨兵位结点   （推荐）
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* cur = head;
    struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(guard);
    struct ListNode* tail = guard;
    while(cur)
    {
        if(cur->val != val)
        {
            tail->next = cur;
            cur = cur->next;
            tail = tail->next;
        }
        else
        {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);
        }
    }
    //注意，一定要判断tail是否为空
    if(tail)
        tail->next = NULL;
    head = guard->next;
    free(guard);

    return head;
}

在这里插入图片描述

算法复杂度： 时间复杂度：O(n)，空间复杂度：O(1)。

2. 反转链表

OJ链接

题目要求：
在这里插入图片描述
解析：

  1. 法一：

    • 将头结点后面的结点依次摘下，放到头结点前面。
    • 特殊情况不需要反转：链表为空或只有一个结点。
      在这里插入图片描述
struct ListNode* reverseList(struct ListNode* head){
    //head为空，或head->next为空，就没必要反转
    if(!head || !head->next)
    {
        return head;
    }

    struct ListNode* cur = head->next;
    struct ListNode* newHead = head;
    while(cur)
    {
        head->next = cur->next;
        cur->next = newHead;
        newHead = cur;
        cur = head->next;
    }

    return newHead;
}

算法复杂度： 时间：O(n)，空间O(1)。

在这里插入图片描述

  1. 法二（推荐）：

    反转“指针”。
    在这里插入图片描述

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* prev = NULL, *cur = head;
    while(cur)
    {
        struct ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

算法复杂度： 时间：O(n)，空间：O(1)。

在这里插入图片描述

3. 链表的中间结点

OJ链接

题目要求：
在这里插入图片描述

解析：

  • 快慢指针。
  • slow一次走一步，fast一次走两步。
  • 当fast为空或者fast->next为空时，结束。
  • 此时，slow所指向的结点就是中间结点。
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* fast, *slow;
    fast = slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

算法复杂度： 时间：O(n)，空间：O(1)。
在这里插入图片描述

4. 链表中倒数第k个结点

OJ链接

题目要求：
在这里插入图片描述
解析：

  • 思路和上一题相似。
  • 先让fast走k步，再同时走。
  • 一般情况下：当fast为空时，结束。此时，slow所指向的结点即为所求结点。
  • 特殊情况：k>链表长度。所以，需要判断结束条件，如果fast为空，但fast还没有走完k步，就返回NULL。
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast, *slow;
    fast = slow = pListHead;
    
    //先让fast走k步
    while(fast && k--)
    {
        fast = fast->next;
    }
    //k>链表长度
    if(k > 0)
        return NULL;
    
    while(fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

算法复杂度： 时间：O(n)，空间：O(1)。
在这里插入图片描述

5. 合并两个有序链表

OJ链接

题目要求：
在这里插入图片描述
解析：

  • 创建一个哨兵位结点guard，尾指针tail指向guard。
  • 将原先两个链表中首结点（cur1和cur2）小的的结点链接到tail后面（相当于在tail后面链接了一个链表）。再让该结点后移。重复此过程。
  • 当cur1和cur2中一个为空时（链表为空），结束。
  • 将另一个不为空的链表链接到tail后面。
  • 最后，返回guard->next。
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(guard);
    guard->next = NULL;
    struct ListNode* tail = guard;
    struct ListNode* cur1 = list1, *cur2 = list2;
    while(cur1 && cur2)
    {
        if(cur1->val < cur2->val)
        {
            tail->next = cur1;
            tail = tail->next;
            cur1 = cur1->next;
        }
        else
        {
            tail->next = cur2;
            tail = tail->next;
            cur2 = cur2->next;
        }
    }
    if(cur1)
    {
        tail->next = cur1;
    }
    if(cur2)
    {
        tail->next = cur2;
    }
    return guard->next;
}

算法复杂度： 时间：O(n)，空间O(1)。
在这里插入图片描述

6. 链表分割

OJ链接

题目要求：
在这里插入图片描述
解析：

  • 创建两个哨兵位结点GreaterGuard，LessGuard，及尾指针GreaterTail，LessTail指向哨兵位结点。
  • 用cur（起初cur指向原链表头结点）遍历原链表。依次将小于x的结点链接到LessTail后面，不小于x的结点链接到GreaterTail后面。
  • cur为空（即原链表为空）时，将GreaterGuard链表（不包括头结点）链接到LessGuard链表后面。
  • 注意！！！将最终得到的链表的结尾置为NULL。
  • 最后，返回最终得到的链表LessGuard（不包括头结点）。
class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* LessGuard, *LessTail, *GreaterGuard, *GreaterTail;
        LessGuard = (ListNode*)malloc(sizeof(ListNode));
        GreaterGuard = (ListNode*)malloc(sizeof(ListNode));
        assert(LessGuard && GreaterGuard);
        LessTail = LessGuard;
        GreaterTail = GreaterGuard;
        GreaterTail->next = LessTail->next = NULL;//也可以不写
        
        ListNode* cur = pHead;
        while(cur)
        {
            if(cur->val < x)
            {
                LessTail->next = cur;
                LessTail = LessTail->next;
                
                //cur = cur->next;
            }
            else
            {
                GreaterTail->next = cur;
                GreaterTail = GreaterTail->next;
                //cur = cur->next;
            }
            cur = cur->next;
        }
        LessTail->next = GreaterGuard->next;
        GreaterTail->next = NULL;//注意，这一步不能省略
        
        pHead = LessGuard->next;
        free(LessGuard);
        free(GreaterGuard);
        
        return pHead;
    }
};

算法复杂度： 时间：O(n)，空间O(1)。
在这里插入图片描述

7. 回文链表

OJ链接

题目要求：

在这里插入图片描述

解析：

  • 找到中间结点。
  • 反转中间结点之后的链表（包括中间结点）。
  • 将原链表head和反转后的后半部分链表遍历比较。
  • 循环结束条件：两链表当前遍历比较的结点只要有一个为NULL（考虑到原链表结点数为偶数时），就结束。
  • 由于，找中间结点和反转链表前面已经论述过，便不再细述。
    在这里插入图片描述
 //找中间结点
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* fast, *slow;
    fast = slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}
//翻转链表
struct ListNode* reverseList(struct ListNode* head){
        struct ListNode* prev = NULL;
        struct ListNode* cur = head;
        while(cur)
        {
            struct ListNode* next = cur->next;
            cur->next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
bool isPalindrome(struct ListNode* head){
    struct ListNode* mid = middleNode(head);
    struct ListNode* rmid = reverseList(mid);
    struct ListNode* cur = head;
    while(cur && rmid)
    {
        if(cur->val != rmid->val)
            return false;
        cur = cur->next;
        rmid = rmid->next;
    }
    return true;
}

算法复杂度： 时间：O(n)，空间：O(1)。

在这里插入图片描述

8. 相交链表

OJ链接

题目要求：
在这里插入图片描述

解析：

  • 判断两链表是否交叉。遍历两个链表headA和headB，若它们的尾结点地址相同，则交叉；否则，不交叉，返回NULL。
  • 若链表交叉，找相交的起始结点。想办法让两个链表从各自与相交的起始结点距离相同的结点同时出发，当两链表用于遍历的结点cur的地址相同时，就找到了，返回该地址。
    • 在遍历链表的同时，计算两链表的长度len1和len2。得出长度之差gaplen，让长的链表先走gaplen步，两链表再同时走。
    • 当cur1和cur2相同时，返回当前地址。
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
    if (!headA || !headB)
        return NULL;
    struct ListNode* cur1 = headA;
    struct ListNode* cur2 = headB;
    int len1 = 1;
    int len2 = 1;
    //找尾结点，并记录链表长度
    while (cur1->next)
    {
        cur1 = cur1->next;
        len1++;
    }
    while (cur2->next)
    {
        cur2 = cur2->next;
        len2++;
    }
    //两链表不交叉
    if (cur1 != cur2)
    {
        return NULL;
    }
    //
    struct ListNode* LongList = headA;
    struct ListNode* ShortList = headB;
    if (len1 < len2)
    {
        LongList = headB;
        ShortList = headA;
    }
    //长度的差值
    int gap = abs(len1 - len2);
    //长的先走差值步
    while (gap--)
    {
        LongList = LongList->next;
    }
    //同时走
    while (LongList != ShortList)
    {
        LongList = LongList->next;
        ShortList = ShortList->next;
    }
    
    return LongList;
}

算法复杂度： 时间：O(N)，空间：O(1)
在这里插入图片描述

9.环形链表

OJ链接
题目要求：
在这里插入图片描述
解析：

  • 快慢指针。初始slow和fast都指向头结点。
  • slow和fast同时走，slow走一步，fast走两步。
  • 如果链表有环，那么两指针一定会在换种相遇。否则，fast先走到链表的末尾，循环结束。程序结束。
bool hasCycle(struct ListNode *head) {
    struct ListNode* slow, *fast;
    slow = fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        //相遇即带环
        if(fast == slow)
            return true;
    }
    return false;
}

算法复杂度： 时间：O(N)，空间：O(1)
在这里插入图片描述
拓展：

  1. 为什么满指针每次走一步，快指针每次走两步可以？

    假设链表带环，那么最终慢指针和快指针都会进环。快指针先进环，慢指针后进环。最坏的情况是：慢指针刚进环时，快指针恰好在慢指针前面一步（环内），此时两者之间的距离是环的长度-1。慢指针走一步，快指针走两步，（可以根据相对运动的角度理解：慢指针不动，快指针走一步），每次两指针之间的距离都会-1，那么最终就一定会追上。

  2. 快指针每次走3步、4步、… … 、n步可以吗？

    假定快指针每次走3步，环的长度为C。慢指针进环时，两指针之间的距离是X。每次循环（走）两指针之间的距离X减2。

    • 如果进环时，环长C是偶数，两指针之间的距离X也是偶数，最终，会追上（fast==slow）；
    • 如果进环时，环长C是偶数，两指针之间的距离X是奇数，每次距离减2，最终，两指针会错过（fast ==slow->next），此时两指针之间的距离X是C-1（奇数），每次距离减2，就会永远错过，不会相遇（fast ==slow）。

10.环形链表 II

OJ链接
题目要求：
在这里插入图片描述
解析：

  1. 法一（推荐）：

    • 思路与上一题类似。
    • 先判断是否有环（按照上一题的思路）。
    • 若有环：定义一个新指针meet=slow（相遇结点位置），cur=head（头结点）。两指针同时走，当两指针相遇（cur==meet），相遇的结点即为入环的第一个结点。
      在这里插入图片描述
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* fast = head, *slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
        {
            struct ListNode* meet = slow;
            struct ListNode* cur = head;
            //一个指针从头走，同时另一个指针从相遇点走，两者会在入环的第一个结点相遇
            while(meet != cur)
            {
                cur = cur->next;
                meet = meet->next;
            }
            return meet;
        }
    }
    return NULL;
}

算法复杂度： 时间：O(N)，空间：O(1)。
在这里插入图片描述

  1. 法二：
  • 同样，先判断是否有环。
  • 若有环：将环从相遇点断开，转换成求相交链表的第一个公共结点问题（本文第8题）
//求相交链表的第一个公共结点
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
    if (!headA || !headB)
        return NULL;
    struct ListNode* cur1 = headA;
    struct ListNode* cur2 = headB;
    int len1 = 1;
    int len2 = 1;
    //找尾结点，并记录链表长度
    while (cur1->next)
    {
        cur1 = cur1->next;
        len1++;
    }
    while (cur2->next)
    {
        cur2 = cur2->next;
        len2++;
    }
    //两链表不交叉
    if (cur1 != cur2)
    {
        return NULL;
    }
    //
    struct ListNode* LongList = headA;
    struct ListNode* ShortList = headB;
    if (len1 < len2)
    {
        LongList = headB;
        ShortList = headA;
    }
    //长度的差值
    int gap = abs(len1 - len2);
    //长的先走差值步
    while (gap--)
    {
        LongList = LongList->next;
    }
    //同时走
    while (LongList != ShortList)
    {
        LongList = LongList->next;
        ShortList = ShortList->next;
    }
    
    return LongList;
}
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head, *fast = head;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow)
        {
            struct ListNode* meet = slow;
            struct ListNode* next = meet->next;
            //将环断开，变成相交链表问题
            meet->next = NULL;
            struct ListNode* entryNode = getIntersectionNode(head, next);
            meet->next = next;
            return entryNode;
        }
    }
    return NULL;
}

算法复杂度： 时间：O(N)，空间：O(1)
在这里插入图片描述

11. 复制带随机指针的链表

OJ链接
题目要求：
在这里插入图片描述
解析：

  1. 复制结点。依次创建同类型的结点，插入到原链表中的两个结点之间。
  2. 改变复制结点的random。
    • 若原链表中对应结点（被复制的结点）的random指向NULL，则复制结点的random也指向NULL。
    • 否则，让复制结点的random指向原链表中对应结点（被复制的结点）的random->next。
  3. 恢复原链表，链接新链表。将原链表的next指针恢复，并且将复制结点链接起来，组成一个原链表的复制链表。
    在这里插入图片描述
struct Node* copyRandomList(struct Node* head) {
   struct Node* cur = head;
   struct Node* copy = NULL;
   struct Node* next = NULL;
   //复制
   while(cur)
   {
       copy = (struct Node*)malloc(sizeof(struct Node));
       assert(copy);
       copy->val = cur->val;
       next = cur->next;

       cur->next = copy;
       copy->next = next;
       
       //后移
       cur = next;
   }
   //链接random指针
   cur = head;
   while(cur)
   {
       copy = cur->next;
       if(cur->random == NULL)
           copy->random = NULL;
       else
           copy->random = cur->random->next;

       cur = cur->next->next;
   }
   //还原原链表
   struct Node* copyhead = NULL, *copytail = NULL;
   cur = head;
   while(cur)
   {
       copy = cur->next;
       next = copy->next;
       //取copy结点 尾插
       if(copytail == NULL)
       {
           copyhead = copytail = copy;
       }
       else
       {
           copytail->next = copy;
           copytail = copytail->next;
       }
       //恢复原链表
       cur->next = next;

       cur = next;
   }

   return copyhead;
}

算法复杂度： 时间：O(N)，空间：O(1)。

丨归凡
关注
专栏目录
【数据结构】链表OJ特别篇 —— 面试情景带你深度剖析 环形链表系列问题 && 复制带随机指针的链表
StackFrame
11-09 1387
模拟面试情景详解：环形链表系列问题、复制带随机指针的链表
【数据结构】队列详解 && 栈和队列OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
StackFrame
11-16 1163
队列的概念和结构讲解、C语言实现队列、OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
盘点那些必问的数据结构算法题之链表
Java面试精选的博客
07-03 415
0 概述 链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的仓库中拷贝了一份用于测试用，本文的相关代码在 这里。 https://github.com/shishujuan/data-structure-algorithms 1 定义 先定义一个单向链表结构，如下，定义了链表
链表题目汇总
huangxy10的专栏
09-23 2935
单链表 目录 1.单链表反转 2.找出单链表的倒数第4个元素 3.找出单链表的中间元素 4.删除无头单链表的一个节点 5.两个不交叉的有序链表的合并 6.有个二级单链表，其中每个元素都含有一个指向一个单链表的指针。 写程序把这个二级链表称一级单链表。 7.单链表交换任意两个元素（不包括表头） 8.判断单链表是否有环？如何找到环的“起始”点？如何知道环的长度？ 9.判断两个单链
单链表OJ题（1）：移除链表元素
最新发布
2301_80966914的博客
10-26 1047
修改完之后，节点的关系如图所示，原链表的节点指向被改变，尾节点的next域为NULL。时的尾指针可能没有指向原链表的节点，也就是此时newTail尾NULL。创建头指针指向新链表的第一个节点和尾指针指向新链表的最后一个节点。这里，因为解法一有头节点的存在，我们在实现尾插的时候，就。时要将头指针和尾指针都指向这个节点当新链表的第一个节点。对尾指针指向的节点置为NULL的时候。要把节点插入到尾指针指向节点的后面。，因为此次的尾指针指向的是头节点。当尾指针指向的节点不存在的时候。查找节点值不为val的节点。
数据结构链表例题
c_living的博客
07-09 970
给定一个链表L，链表中的整数数据是唯一的。给定一个数组G，G中的数据全是链表L中的数，但是顺序可能是打乱的。现在要判断G中的数据在对应链表中的数据位置是否是连接上的，并求出链接上的组数。例如：L：0-&gt;7-&gt;2-&gt;9-&gt;4G:{0,9,7,4}结果返回：2，因为{0，7}在L中式连续的，{9，4}在L中是连续的，3个连续或者更多同样算一个。当最后只有一个的情况下是视为一个连...
链表相关题解
travel_dream的博客
04-09 1183
以下题目皆来自力扣和牛客，可以通过搜索题目名找到对应题目 前期最好配合画图进行解题，要进行特殊情况的考虑。 在进行链表题训练时，最好自己先画图，然后再进行代码的书写，卡壳了或者完全没有思路再看解析。只看完本篇文章不代表你能从容解决链表题。 1. 删除链表中等于给定值 val 的所有节点。//这里的头结点是链表实现的一种方式，后面会介绍到。 画图分析，因为返回头结点，所以可以不用考虑头指针的因素。在实现单链表时也可以这样创建节点，但是要额外创建变量接受指针(返回值)，每次创建节点都要创
数据结构与算法-链表练习题
freshbin000的博客
05-04 623
leetcode的几道链表练习题： package com.freshbin.basics.linkedlist; /** * @author freshbin * @date 2020/5/2 14:54 */ public class ListNode { int val; ListNode next; ListNode(int x) { ...
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
《西南科技大学SWUST OJ线性结构链表题解答案详解》 在计算机科学中，线性结构是一种基本的数据组织形式，它包含了数组和链表等常见数据结构。本资料集中，我们主要关注的是链表相关的题目解答，这些题目来自西南...
ACM竞赛中的OJ与常用算法数据结构详解
通过参与OJ平台，如UVA、ZOJ、URAL和USACO等，学生们可以接触到丰富多样的算法和数据结构题目，提升自身的竞赛能力和行业竞争力。 在竞赛中，常见的题型包括但不限于数组和链表操作、字符串处理、动态规划、图论、...
Java - 数据结构之 顺序表与链表
m0_65638983的博客
12-25 629
假设当前有n个元素，第1个元素和第n个元素相等，第二个元素个第n-1个元素相等......直到中间只剩一个元素时(奇数个) 或者中间没有元素(偶数个)时称为回文这道题的思路又是好几个小题，首先是找出中间结点，其次反转中间结点后的链表，最后使用双指针从前后遍历即可力扣反转链表：力扣。
经典链表--题型详解
！
04-04 1656
链表基础题，常见常用的几种思路
数据结构oj_3
weixin_44770733的博客
10-25 310
在序列指定位置插入元素（数组） 问题描述 : 使用数组编程： 一群学生排成一行，输入一个位置和一个学号，在该位置插入一个学生。 第一个学生的位置为1，第n个学生的位置为n。 输入说明 : 第一行输入学生信息： 第一个整数n(0<=n<=100)，表示共有n个学生，其后有n个整数，表示n个学生的学号 第二行及以后各行，每行输入两个整数，表示要插入的位置及学号。 输出说明 : 每次插入一个学生后，在一行里输出完整的学号序列，学号之间以一个空格分隔。 如果需要插入学生的位置不合法，则输出“invali
数据结构与算法-链表题-总结
qfikh的博客
12-19 473
本文将总结Leetcode和剑指offer已有的链表相关的题目和解答，有简入难。 1、删除链表的节点 (1)、O(1)时间删除链表节点 题目：给定一个链表和一个节点指针，在O(1)时间删除该节点。 方法：狸猫换太子，用后一个节点数据覆盖要删除的节点，然后删除下一个节点。 leetcode 237. Delete Node in a Linked List（删除链表中的特定节点） ...
链表oj题
weixin_45726063的博客
08-13 234
删除链表中等于给定值 val 的所有节点。 struct ListNode* removeElements(struct ListNode* head, int val){ struct ListNode*cur=head; struct ListNode*prev=NULL; while(cur) { if(cur->val==val) { if(cur==head) { head=cur->n.
数据结构oj_11
weixin_44770733的博客
10-26 259
求序列的交集（链表） 问题描述 : 使用带头结点的单链表编程： 有两个序列，分别表示两个集合。 求它们的交集并输出。 输入说明 : 第一行输入序列A的信息： 第一个整数n(0<=n<=100)，表示共有n个元素，其后有n个整数，表示n个元素的数据 第一行输入序列B的信息： 第一个整数n(0<=n<=100)，表示共有n个元素，其后有n个整数，表示n个元素的数据 输出说明 : 输出交集的元素序列，输出格式见范例。 如果交集为空，则输出“head–>tail” 交集里的元素顺序，依
数据结构链表题集
qq_53893431的博客
05-06 915
题目一：113 · 删除排序链表中的重复数字（二） - LintCode 思路：创建哨兵位头结点，原地删除 class Solution { public: /** * @param head: head is the head of the linked list * @return: head of the linked list */ //带哨兵位的删除方法 ListNode* deleteDuplicates(ListNode *hea.
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1815
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

丨归凡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值