【数据结构】链表OJ - 精选精讲

文章目录

  • 前言
  • 一、注意事项
  • 二、OJ精讲
    •   1.移除链表元素
    •   2. 反转单链表
    •   3. 链表的中间节点
    •   4. 链表中倒数第K个节点
    •   5.合并两个有序链表
    •   6.链表的回文结构
    •   7. 相交链表
  • 总结


前言

本文选取了一些经典的来自力扣和牛客的链表OJ题,并提供优质,值得借鉴的思路供读者积累与掌握。均配有步骤图解


一、注意事项

我们在学习数据结构时刷题很重要,刷题的时候画图很重要,学会作图才能理解其中的核心思想,代码的实现反而是其次的,要画图,然后看图写代码。本文在讲解时也遵循先解析思路,配图,再进行代码实现的先后顺序。

二、OJ精讲

  1.移除链表元素

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第1张图片
  • 思路讲解

整体:从头开始遍历链表,把不是val值的节点取下来尾插进新链表。
拆分:

  1. 准备工作,初始化指针
  2. 分是val和不是val两种情况,其中是val时要格外讨论是否为第一次插入新表。

【数据结构】链表OJ - 精选精讲_第2张图片
【数据结构】链表OJ - 精选精讲_第3张图片

  • 代码实现
struct ListNode* removeElements(struct ListNode* head, int val)
 {
    struct ListNode* tail = NULL;
    struct ListNode* newhead = NULL;
    struct ListNode* cur = head;


    while (cur)
    {
        if (cur->val != val)
        {
            if (newhead == NULL)
            {
                newhead = cur;
                tail = newhead;
            }
            else
            {
                tail->next = cur;
                tail = tail->next;
            }
            cur = cur->next;
        }
        else
        {
            struct ListNode* tmp = cur;
            cur = cur->next;
            free(tmp);
        }
    }
     if(tail)
        tail->next = NULL;
    return newhead;
}


  2. 反转单链表

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第4张图片
  • 思路讲解

从头开始依次反转节点指向,并更新头结点

【数据结构】链表OJ - 精选精讲_第5张图片

  • 代码实现
struct ListNode* reverseList(struct ListNode* head) {
    if(head == NULL)
        return NULL;
      struct ListNode* cur = head;
      struct ListNode* next = cur->next;
      struct ListNode* newhead = NULL;

      while(cur)
      {
          cur->next = newhead;
          newhead = cur;
          cur = next;
          if(next)
            next = next->next;
      }
      return newhead;
}


  3. 链表的中间节点

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第6张图片
  • 思路讲解

快慢指针法
让fast指针一次走两步,slow一次走一步,当fast走到尾节点或NULL时,slow位置即为中间节点。对于本题,节点个数为奇数和偶数在代码实现上是一样的,不必分开讨论。

【数据结构】链表OJ - 精选精讲_第7张图片
【数据结构】链表OJ - 精选精讲_第8张图片

  • 代码实现
struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* fast = head;
    struct ListNode* slow = head;

    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    
    return slow;
}


  4. 链表中倒数第K个节点

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第9张图片
  • 思路讲解

快慢指针法
fast 先走K步,再同时走,当fast为空时,slow位置为倒数第K个节点。
类似于上题,读者可以尝试自行使用快慢指针法画图求解

  • 代码实现
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast = pListHead;
    struct ListNode* slow = pListHead;

    while(k--)
    {
        if(fast == NULL)
            return NULL;
        fast = fast->next;
        
    }
    while(fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}

  5.合并两个有序链表

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第10张图片
  • 思路讲解

分别从头遍历给定的两个链表,进行节点值的比较,将较小的先尾插到一个新链表。

  • 代码实现
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {

	  if(list1 == NULL)
	    return list2;
	  if(list2 == NULL)
	    return list1;
	  if(list1==NULL && list2==NULL)
	    return NULL;

     struct ListNode* cur1 = list1;
     struct ListNode* cur2 = list2;
     struct ListNode* newhead = NULL;
     struct ListNode* tail;

     while(cur1 && cur2)
     {
       if(cur1->val <= cur2->val)
       {
            if(newhead == NULL)
                tail = newhead = cur1;
            else
            {
              tail->next = cur1;
              tail = tail->next;
            }
            cur1 = cur1->next;
       }
       else
       {
            if(newhead == NULL)
                tail = newhead = cur2;
            else
            {
              tail->next = cur2;
              tail = tail->next;
            }
         cur2 = cur2->next;
       }
     }

     if(cur1)
     {
       tail->next = cur1;
     }
     if(cur2)
     {
         tail->next = cur2;
     }
     
     return newhead;
}

  6.链表的回文结构

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第11张图片
  • 思路讲解

1.找到中间节点
2.反转链表后半部,使原链表拆分为两个链表
3.两个新链表从头开始依次比较节点的val值,均相同则为回文结构,否则不为回文结构。

【数据结构】链表OJ - 精选精讲_第12张图片

  • 代码实现
class PalindromeList {
    struct ListNode* reverseList(struct ListNode* head) {
        if (head == NULL)
            return NULL;
        struct ListNode* cur = head;
        struct ListNode* next = cur->next;
        struct ListNode* newhead = NULL;

        while (cur) {
            cur->next = newhead;
            newhead = cur;
            cur = next;
            if (next)
                next = next->next;
        }
        return newhead;
    }

    struct ListNode* middleNode(struct ListNode* head) {
        struct ListNode* fast = head;
        struct ListNode* slow = head;

        while (fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
        }

        return slow;
    }
  public:
    bool chkPalindrome(ListNode* head) {

        ListNode* mid = middleNode(head);
        ListNode* newhead = reverseList(mid);
        while (head && newhead) 
        {
            if(head->val != newhead->val)
                return false;

            head = head->next;
            newhead = newhead->next;
        }
        return true;
    }
};


  7. 相交链表

  • 题目描述
    【数据结构】链表OJ - 精选精讲_第13张图片
  • 思路讲解

1.判断是否相交
  分别找尾,尾节点相同则相交。
2.找交点
  快慢指针法。计算出两表长度,长表先从头走差距步,再同时走,直到节点地址相同时停下,即为交点。

  • 代码实现
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    //1.判断是否相交,顺便计算A,B长度
    struct ListNode * tailA = headA;
    struct ListNode * tailB = headB;
    int lenA = 1;
    int lenB = 1;

    while(tailA->next)
    {
        tailA = tailA->next;
        lenA++;
    }
    while(tailB->next)
    {
        tailB = tailB->next;
        lenB++;
    }
    if(tailA != tailB)
        return NULL;
    
    //2.找交点
    //假设法精简代码
    struct ListNode * longlist = headA;
    struct ListNode * shortlist = headB;
    //lenA与lenB差值的绝对值
    int n = abs(lenA-lenB);
    if(lenA < lenB)
    {
        longlist = headB;
        shortlist = headA;
    }
    while(n--)
    {
        longlist = longlist->next;
    }
    while(longlist != shortlist)
    {
        longlist = longlist->next;
        shortlist = shortlist->next;
    }
    return longlist;

}


总结

本文精选了链表经典OJ题,有些思路对初学者来说可能是第一次见,我们要学会站在巨人的肩膀上,将它们消化吸收,在往后的实践中运用能达到很好的效果。如果对你有所帮助,还望点赞收藏支持博主。
文章中有什么不对的丶可改正的丶可优化的地方,欢迎各位来评论区指点交流,博主看到后会一一回复。

你可能感兴趣的:(数据结构,数据结构,链表,c++,c语言)