代码随想录算法训练营第三天| 203.移除链表元素、707.设计链表、206.反转链表

原创已于 2022-12-30 15:38:16 修改 · 107 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #算法 #数据结构

于 2022-12-30 15:35:38 首次发布

代码随想录训练营专栏收录该内容

10 篇文章

订阅专栏

这篇博客探讨了链表的基本概念，包括单链表、双链表和循环链表，并通过203.移除链表元素、707.设计链表和206.反转链表的题目，详细解析了解题思路和代码实现。作者分享了在解决链表问题时遇到的挑战，如赋值错误和对象理解，并提供了改进后的代码。此外，还涉及到了链表的创建、插入和删除操作。

一、今日任务

二、203. 移除链表元素

2.1 题目：203. 移除链表元素

2.2 解题过程

首先看一下理论基础部分，链表是真的让人感到害怕的一种数据结构。

比较基础的几个链表为单链表、双链表和循环链表。

链表中各节点散乱地分布在内存中。

链表的一些基本操作：删除节点、添加节点。

链表用于常插入少查询。

解题思路：从头结点遍历，遇到val值相等，执行删除节点动作，直至遍历完成。

思路很简单，但是整整花了一个小时才完全写出来。

首先是一个赋值号打错成等于判断。导致一直出不来结果。

其次是对于对象的赋值是非常陌生的。

其次是对于返回值的选定，这里突出的是深浅赋值的问题。

以下是相关代码：

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        p_prev = ListNode(next = head) #创建和赋值
        p_cur = p_prev.next
        p_rem = p_prev
        while p_cur != None:           
            if p_cur.val == val:
                p_prev.next = p_cur.next
                p_cur = p_cur.next
            else:
                p_prev = p_prev.next
                p_cur = p_cur.next
        return p_rem.next

2.3 阅读材料改进

文章中代码显然比自己的会更加简单清晰。

以下是复现代码：

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        p_prev = ListNode(next = head) #创建和赋值
        p_cur = p_prev
        while p_cur.next != None:           
            if p_cur.next.val == val:
                p_cur.next = p_cur.next.next
            else:
                p_cur = p_cur.next
        return p_prev.next

三、707. 设计链表

3.1 题目：707. 设计链表

3.2 解题过程

整体来说还是比较简单的一个过程。在以前学习c++的时候疯狂练习过一段时间。知识换了语言，对于一些定义的使用不够熟悉。

以下是自己的代码：

class LinkNode(object):
    def __init__(self, val=0, next = None):
        self.val = val
        self.next = next

class MyLinkedList(object):

    def __init__(self):
        self.head = LinkNode()
        self.length = 0

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        search = self.head
        temp = -1
        while search != None:
            if temp == index:
                return search.val
            temp += 1
            search = search.next
        return -1

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        NewNode = LinkNode(val, next = self.head.next)
        self.head.next = NewNode
        self.length += 1


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        NewNode = LinkNode(val)
        tail = self.head
        while tail.next != None:
            tail = tail.next
        tail.next = NewNode
        self.length += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index == self.length:
            self.addAtTail(val)
        elif index < 0:
            self.addAtHead(val)
        elif index >self.length:
            pass
        else:
            NewNode = LinkNode(val)
            addr = self.head
            while index > 0:
                addr = addr.next
                index -= 1
            NewNode.next = addr.next
            addr.next = NewNode
            self.length += 1

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        search = self.head
        temp = -1
        while search.next != None:
            if temp == index - 1:
                search.next = search.next.next
                self.length -= 1
                break
            temp += 1
            search = search.next

3.3 阅读材料改进

实在提不起兴趣再来一遍双链表。后期遇到再写吧。

四、206. 反转链表

4.1 题目：206. 反转链表

4.2 解题过程

根据提示使用递归，这是自己第一次独立写出一个递归，尽管比较简单，但是也非常开心！！

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None:
            return head
        if head.next != None:
            NewHead = self.reverseList(head.next)
            NewNode = ListNode(head.val)
            NewTail = NewHead
            while NewTail.next != None:
                NewTail = NewTail.next
            NewTail.next = NewNode
        elif head.next == None:
            NewHead = ListNode(head.val)
        return NewHead

4.3 阅读材料改进

随想录中的迭代法和递归法，短短几行，有点难以理解。

画图稍微理解了以下，

temp的作用是暂时记录还未处理的链表，prev用以记录已反转的链表：

以下是迭代法复现：

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        cur = head
        pre = None
        while cur != None:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur =temp
        return pre

按照文章所说，递归法和迭代法思路相同。

最原始条件是两个反转。

class Solution(object):

    # 迭代法
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        def reverse(cur, pre):
            if cur == None:
                return pre
            temp = cur.next
            cur.next = pre
            return reverse(temp, cur)
        return reverse(head, None)