Leetcode链表相关总结

最新推荐文章于 2023-02-10 20:28:28 发布

九城风雪

最新推荐文章于 2023-02-10 20:28:28 发布

阅读量281

点赞数 2

分类专栏： LeetCode 文章标签：链表 leetcode 算法

原文链接：https://blog.csdn.net/qq_42633819/article/details/88318968?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-1.essearch_pc_relevant&spm=1001.2101.3001.4242.2

版权

LeetCode 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

做leetcode链表题的时候，需要额外考虑链表头部的特殊情况。但是，往往考虑不够周全，导致最后通过不断试错，修改代码。代码变得臃肿，可读性差。
其实，引入一个dummy节点就可以解决大部分需要考虑头节点的链表题。

什么是dummy节点？

dummy（假的）节点是一个虚拟创建的节点，放在链表的最前面，指向头节点

let dummy = new ListNode(); //创建新节点
dummy.next = head;  //让dummy指向头节点
//...
//...
return dummy.next;  //程序结束后返回链表，返回的是dummy.next，而非dummy

使用dummy的场景有哪些？

前面提到，使用dummy可以避免很多由于头节点特殊性产生的坑，让代码更优雅。
那么dummy的应用场景主要有以下两类：

作为新链表的头部
（可参考leetcode第2题、第21题）
解决链表的头部引起的极端问题
（可参考leetcode第19题、第24题）
总结
使用dummy最主要的原因是消除头节点的特殊性，使用一个虚拟节点冒充头节点，而真正的头节点就和其他普通节点一样。
当我们处理完链表之后，只需要返回dummy.next，由于单向链表只能从头往后遍历的性质，就可以舍弃掉dummy，返回的就是我们需要的链表。

创建哑节点

在链表的操作中，添加一个哑节点（dummy node），让它的指针指向链表的头节点，这样在删除节点的时候，就不需要再判断删除的是否是头结点了。

ListNode* dummy = new ListNode(0, head);

这里new dummy的含义：dummy->val = 0, dummy->next = head;
即：数据域为0，指针域指向链表的头结点

Dummy Node小技巧

题目：给定一个有序链表，删除所有重复的节点，只留下原链表中出现一次的元素。

例如：给定链表1->2->3->3->4->4->5 返回1->2->5

给定链表1->1->1->2->3 返回2->3

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead){

        if (pHead == null || pHead.next == null){
            return pHead;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = pHead;
        ListNode pre  = dummy;
        ListNode cur = pHead;
        while (cur != null) {
            // 如果cur和cur.next的值相等，那么把cur移动到重复节点的最后一个节点
            if (cur.next != null && cur.val == cur.next.val) {
                while (cur != null && cur.next != null && cur.val == cur.next.val) {
                    cur = cur.next;
                }
                // 连接pre和cur.next,构造不重复的节点
                pre.next = cur.next;
                cur = cur.next;
            } else {
                // pre和cur都后移一位
                pre = pre.next;
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

链表知识点：

1）通过指针将内存块串联起来，内存块为链表的节点，每一个节点除了存储的数据还有一个指向下一个节点的next指针。如果是双向链表的话，在节点处除了next指针还有前向指针。

2）搜索链表时间复杂度是O(n)，不能以索引的方式读取节点值。

3）链表的优势在于可以很高的效率在任意位置插入和删除一个节点。

4）单向链表每一个节点包括一个值和一个指向下一个节点的指针。尾节点的next指针指向空指针Null。

5）循环链表，尾节点的空指针不指向Null，反而指向头节点，如果数据是环形的适合采用循环链表来处理。

6）双向链表，每个节点除了有指向下一个节点的指针，还有指向上一个节点的指针。

7）数组插入删除的时间复杂度是：O(n)，链表的时间复杂度是：O(1)；数组随机访问的时间复杂度是O(1)，链表时间复杂度是O(n)。

8）链表的优点是：动态扩容，不需要占用过多的内存；缺点是，访问一个值需要遍历

9）链表技巧：使用dummy node。dummy node 就是在链表的head前加一个节点指向head。通常情况下，如果链表的head发生变化，比如需要删除或者修改，可以创建dummy node。这样操作head和其他节点没有区别。

10）链表技巧：双指针。对于寻找链表的某一个位置，比如中点，或者是判断是否有环的问题时，可以使用快慢指针，slow和fast。

11）链表技巧：交换节点的处理。如果想要交换两个节点的位置，可以采用这两个步骤，1）先交换两个前驱节点的next指针的值，2）再交换这两个节点的next指针的值。比如24题。

12）链表技巧：同时处理两个链表的处理方法。

可能出现的题型：

1、删除操作

描述：删除链表中的第n个节点

解法：采用双指针法。在head前面加一个dummy node的虚拟节点，设置两个指针一个fast，一个slow。fast先向前移动n个节点（由于是从dummy node节点开始移动，所以实际上是移动了n-1位），然后fast和slow同时开始移动，当fast.next指向None时，slow指向的就是需要删除节点的前一个节点。将其指向.next.next就可以。

2、翻转操作

类型1：

描述：翻转一个单向链表

解法：对于翻转类的题型，我们只需要知道head->prev节点如何翻转成prev-head即可,这里我们仍然要用到dummy node，作为head的前驱节点，在翻转前，是dummy->head->2->3…->NULL,翻转后变成NULL->5->…->2->head->dummy，dummy变成了尾节点，因为这是一个单向链表，head只有一个指针，已经指向了下一个节点了，所以首先需要把head的下一个节点，即head.next用一个临时变量存储起来，与head’断开连接’，这样head就可以指向dummy了，即我们将dummy->head变成了head->dummy，第一步完成。后面的处理方式有两种写法，一种是迭代，我们可以再来用同样的方式处理head->head.next ,使之变成head.next->head，同样让head.next.next用一个变量存储起来断开与head.next的连接，然后head.next指向head即可，在这里其实head.next.next就相当于第一步中的head.next,head.next就相当于第一步的dummy,所以可以直接写成dummy = head，head = next；递归的方式则需要c创建一个递归函数，把第一步的步骤写入递归函数里面，然后再不断地调用这个递归函数即可。

参考代码：

# 迭代写法
class Solution(object):
  def reverseList(self, head):
      """
      :type head: ListNode
      :rtype: ListNode
      """
      dummy = None
      while head :
          next = head.next     #把head.next指针用一个临时变量存起来,保证后边的数据不丢失，然后翻转前两个节点。
          head.next = dummy    #然后使head.next翻转指向dummy
          dummy = head     #这里是完成了前两个节点的翻转，继续往下面的节点继续进行
          head = next
      return dummy    #此时的dummy节点指的是翻转之后的head节点。
 
# 递归写法
class Solution(object):
  def reverseList(self,head):
      """
      :type head: ListNode
      :rtype: ListNode
      """
      return self.reverseListHelper(head)
 
  def reverseListHelper(self,head,dummy=None):
      if not head:
          return dummy
      next = head.next    #把后面的节点数据保存下来，
      head.next = dummy    #然后使得head.next指针指向dummy，完成了前两个节点的翻转
      return self.reverseListHelper(next,head)   #递归调用函数

迭代法的时间复杂度是O(n)，空间复杂度是O(1)；递归法的时间复杂度是O(n)，空间复杂度是O(n)。

类型2：

描述：翻转指定位置的链表，m->n；

解法：翻转链表的第一步是找起始的位置和它前面的节点，头节点的前驱节点设置dummy。从m->n翻转，那么在开始处设置为start node，后驱节点设置为then, 即start.next = then，来帮助我们翻转。

比如，有一个链表是1-2-3-4-5，要求你翻转第二位到第四位。

首先，设置虚拟节点dummy，dummy.next = head，利用快慢指针找出开始的节点start，后面第二个指针是then，那么首先由2指向3 改变为 2指向4，即：start.next = then.next；然后，是让3指向4改变为，3指向2，即为then.next = pre.next；然后是让1指向3，即为pre.next = then；然后再往下迭代下一组节点。

参考代码：

     # 迭代法
class Solution(object):
      def reverseBetween(self, head, m, n):
          dummy = ListNode(0)     #设置一个虚拟节点dummy，指向头节点
          dummy.next = head
 
          cur, prev = head, dummy     #cur指的是头节点，prev指的是前一个节点
          for _ in xrange(m - 1):    #循环往后直到要反转的节点处
              cur = cur.next 
              prev = prev.next
 
          for _ in xrange(n - m):   #实现两个节点的翻转
              temp = cur.next   #将后面的隔开保存
              cur.next = temp.next   #使翻转的第一个节点指向翻转的第三个节点
              temp.next = prev.next    #使翻转的第二个节点指向前一个节点
              prev.next = temp     #使翻转节点前的节点指向第二个节点
 
          return dummy.next
 
  # 递归法
  class Solution:
      def reverseBetween(self, head, m, n):
          def reverse(prev, current, m):
              nxt = current.next
              current.next = prev
              if m == 0:
                  return current, nxt
              return reverse(current, nxt, m - 1)
 
          lth = None
          mth = head
 
          for i in range(1, m):
              lth = mth
              mth = mth.next
 
          nth, oth = reverse(lth, mth, n - m)
          if lth:
              lth.next = nth
          else:
              head = nth
          mth.next = oth
          return head

迭代法的时间复杂度是O(n)，因为是在原链表上移动的，所以空间复杂度是O(1)，递归法的时间复杂度是O(n)，空间复杂度是O(n)。

3、合并链表

描述：将两个已经排序的链表合并成新的有序链表

解法：迭代法和递归法。迭代法是每次比较两个结点，把较小的加到结果链表中，并且这个指针向后移动；递归法即每次比较两个链表的头部，将较小的头部单独取出来，剩下的两个部分继续递归。

参考代码：

# 迭代法
def mergeTwoLists1(self, l1, l2):
    dummy = cur = ListNode(0)
    while l1 and l2:
        if l1.val < l2.val:
            cur.next = l1
            l1 = l1.next
        else:
            cur.next = l2
            l2 = l2.next
        cur = cur.next
    cur.next = l1 or l2
    return dummy.next
 
# 递归法    
def mergeTwoLists2(self, l1, l2):
    if not l1 or not l2:
        return l1 or l2
    if l1.val < l2.val:
        l1.next = self.mergeTwoLists(l1.next, l2)
        return l1
    else:
        l2.next = self.mergeTwoLists(l1, l2.next)
        return l2

4、环形链表

描述：判断链表是否存在哪一个环

解法：双指针法。意思是从头设置两个指针，一个快指针走2n步（视具体题目而定），慢指针走n步，当快指针走到尾节点时，满指针正好走到链表的一半（视具体题目而定）。在本题中，设置快指针走两步，慢指针一次走一步，如果快指针走到了尽头，则说明链表无环，如果快指针和慢指针相遇就说明链表有环。为什么呢？我们假设一个有环链表，快慢指针最后都会走到环上，而这个环就像一个环形跑道一样，慢指针在后面，快指针在前面，但实际上快指针也在追慢指针，希望能超慢指针一圈。他们在这个跑道上，总会有一天快指针追上了慢指针。我们不用担心快指针跳过了慢指针，因为他们两的速度差是1，所以它们在环上的距离总是每次减1，最后总能减到0。

参考代码：

 class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
    
    
    try:
        slow = head
        fast = head.next
        while slow is not fast:
            slow = slow.next
            fast = fast.next.next
        return True
    except:
        return False

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

5、拆分链表

描述：给定一个链表以及一个目标值，把小于该目标值的所有节点都移至链表的前端，大于或等于目标值的节点移至链表的尾端，同时要保持这两部分在原先链表中的相对位置。

解法：二分法。设置两个指针left和right，顺序遍历整条链表，left、mid、target三者比较，根据情况left右移或者right左移。关键就在于边界情况和元素有重复。

当 nums[mid] = nums[left] 时，这时由于很难判断 target 会落在哪，那么只能采取 left++

当 nums[mid] > nums[left] 时，这时可以分为两种情况，判断左半部比较简单

当 nums[mid] < nums[left] 时，这时可以分为两种情况，判断右半部比较简单

参考代码：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: bool
        """
        left, right = 0, len(nums)-1   
        while left <= right:   #当左边的数小于右边的数，循环
            mid = left + (right-left)//2   #求中间节点是第几个
            if nums[mid] == target:     
                return True
            while left < mid and nums[left] == nums[mid]: 
                left += 1
 
            if nums[left] <= nums[mid]:
 
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
 
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        return False

6、排序链表

描述：在规定时间复杂度和空间复杂度下，对链表进行排序

解法： **归并排序。**这题有很多解法，题目要有时间复杂度是O(nlogn),满足这个条件的有快速排序，堆排序，归并排序，三者的空间复杂度分别为O(1),O(N),)O(N)。对于链表而言，在进行归并操作时并不需要像数组的归并操作那样分配一个临时数组空间，所以是O(1)的空间复杂度，只需要改变节点的next指针的指向，就可以表示新的归并后的顺序。

参考代码：

class Solution(object):
    def sortList(self, head):
        if not head or not head.next:
            return head
        fast, slow = head.next, head    #两个指针
        while fast and fast.next:   #当都为真的时候
            fast = fast.next.next   #快指针走两步，慢指针走一步
            slow = slow.next 
        second = slow.next   #慢指针就是链表中点的位置，
        slow.next = None       
        l = self.sortList(head) #然后对头节点的前半部分进行同样操作
        r = self.sortList(second)    #对后半链表进行同样操作
        return self.merge(l, r)    #然后将两个链表并在一起
 
    def merge(self, l, r):   
        if not l or not r:    #如果有一个不为空，就返回
            return l or r   
        if l.val > r.val:    #比较两个链表的第一个值，然后交换位置，使l代表小数值的电表，r代表大数值的链表
            l, r = r, l  
        head = pre = l
        l = l.next   #将后边的链表保存
        while l and r:   #当两个链表都为真的时候
            if l.val < r.val: 
                l = l.next
            else:
                next = pre.next
                pre.next = r
                tmp = r.next
                r.next = next
                r = tmp
            pre = pre.next
        pre.next = l or r
        return head

参考：

https://blog.csdn.net/qq_42633819/article/details/88318968?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_title~default-1.essearch_pc_relevant&spm=1001.2101.3001.4242.2

九城风雪

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Leetcode链表相关总结

做leetcode链表题的时候，需要额外考虑链表头部的特殊情况。但是，往往考虑不够周全，导致最后通过不断试错，修改代码。代码变得臃肿，可读性差。其实，引入一个dummy节点就可以解决大部分需要考虑头节点的链表题。什么是dummy节点？dummy（假的）节点是一个虚拟创建的节点，放在链表的最前面，指向头节点let dummy = new ListNode(); //创建新节点dummy.next = head; //让dummy指向头节点//...//...return dummy.nex
复制链接

扫一扫