代码随想录|day3打卡：链表理论基础，203.移除链表元素，707.设计链表，206.反转链表

一 链表理论基础

1 链表类型

单链表

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

双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表 既可以向前查询也可以向后查询。

循环链表

顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

2 链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。

#链表的定义

3 链表的定义

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

4 链表的操作

删除节点

删除D节点，如图所示：

只要将C节点的next指针 指向E节点就可以了。

那有同学说了，D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。

是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

添加节点

如图所示：

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

5 性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景

二 移除链表元素

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

思路

虚拟头结点法
如果使用C，C++编程语言的话，要从内存中删除移除的节点， 清理节点内存
如果使用java ，python的话就不用手动管理内存了。

如果删除的是头结点又该怎么办呢？

这里就涉及如下链表操作的两种方式：

• 直接使用原来的链表来进行删除操作。
• 设置一个虚拟头结点在进行删除操作。

第一种操作：直接使用原来的链表来进行移除。但是这种方式删除头结点和其他节点的代码逻辑不同。

将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。

第二种操作：设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。

最后return 头结点的时候，别忘了 return dummyNode->next;， 这才是新的头结点

代码

# 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 removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dumyhead = ListNode(next=head)
        curr = dumyhead
        while curr.next:
            if curr.next.val == val:
                curr.next = curr.next.next
            else:
                curr = curr.next
        return dumyhead.next

三 设计链表

题目链接：707.设计链表

题意：

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
![在这里插入图片描述](https://img-blog.csdnimg.cn
/direct/37c0727bc4874f8aab9a0e170082268d.png)

思路

删除链表节点：

添加链表节点：

这道题目设计链表的五个接口：

• 获取链表第index个节点的数值
• 在链表的最前面插入一个节点
• 在链表的最后面插入一个节点
• 在链表第index个节点前面插入一个节点
• 删除链表的第index个节点

链表操作的两种方式：

• 直接使用原来的链表来进行操作。

• 设置一个虚拟头结点在进行操作。（方便，推荐）

• 时间复杂度: 涉及 index 的相关操作为 O(index), 其余为 O(1)

• 空间复杂度: O(n)

代码

# 单链表
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class MyLinkedList(object):
    def __init__(self):
        self.dumyhead = ListNode()
        self.size = 0

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        current = self.dumyhead
        if index < 0 or index >= self.size:
            return -1
        else:
            for i in range(index):
                current = current.next
        return current.next.val

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.dumyhead.next = ListNode(val,self.dumyhead.next)
        self.size += 1

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        current = self.dumyhead
        while current.next:
            current = current.next
        current.next = ListNode(val)
        self.size += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        current = self.dumyhead
        if index < 0 or index > self.size:
            return
        if index == self.size:
            self.addAtTail(val)

        elif index < self.size:
            for i in range(index):
                current = current.next
            current.next = ListNode(val,current.next)
            self.size += 1

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        
        if index < 0 or index >= self.size:
            return
        current = self.dumyhead
        if index >= 0 and index < self.size:
            for i in range(index):
                current = current.next
            current.next = current.next.next
            self.size -= 1

## 双链表
class ListNode:
    def __init__(self,val=0,prev=None,next=None):
        self.val = val
        self.prev = prev
        self.next = next
class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0
    def get(self, index):
        if index < 0 or index >= self.size:
            return -1
    
        if index < self.size // 2:
            curr = self.head
            for i in range(index):
                curr = curr.next
                
        else:
            curr = self.tail
            for i in range(self.size - index - 1):
                curr = curr.prev
        return curr.val

    def addAtHead(self,  val):
        new_node = ListNode(val, None, self.head)
        if self.head:
            self.head.prev = new_node
        else:
            self.tail = new_node
        self.head = new_node
        self.size += 1

    def addAtTail(self,  val):
        new_node = ListNode(val, self.tail, None)
        if self.tail:
            self.tail.next = new_node
        else:
            self.head = new_node
        self.tail = new_node
        self.size += 1

    def addAtIndex(self, index,  val):
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index - 1):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index):
                    current = current.prev
            new_node = ListNode(val, current, current.next)
            current.next.prev = new_node
            current.next = new_node
            self.size += 1
    
    def deleteAtIndex(self, index):
        if index < 0 or index >= self.size:
            return
        
        if index == 0:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev
            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            current.prev.next = current.next
            current.next.prev = current.prev
        self.size -= 1

四 反转链表

题目链接：206.反转链表

思路

1.双指针法

• 时间复杂度: O(n)
• 空间复杂度: O(1)

2.递归法

• 时间复杂度: O(n)
• 空间复杂度: O(n)

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点

代码

# 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
        """
        curr = head
        pre = None
        while(curr):
            temp = curr.next
            curr.next = pre
            pre = curr
            curr = temp
        return pre

递归法：

class Solution(object):
    def reverseList(self,head):
        return self.reverse(head,None)
    def reverse(self, curr,pre):
        if curr:
            temp = curr.next
            curr.next = pre
            pre = curr
            curr = temp
            return self.reverse(curr,pre)
        else:
            return pre