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

文档参考：programmercarl.com

203.移除链表元素

移除链表元素，比较简单，对链表有一定理解就能写出来

# 另类写法——添加虚拟头
class Solution_(object):
    def removeElements(self, head, val):
        vir_head = ListNode(next=head)  # 虚拟节点

        cur = vir_head  # 复制一次虚拟节点

        while cur.next != None:  # 判断下一个节点是否存在
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return vir_head.next # 虚拟节点的next节点就是数组正式开始的head节点

707.设计链表

写一个题等于写6个题，血赚，主要就是写链表刚开始没有思路，看了会答案之后就明白了

"""
一开始不知道该怎么写，因为看不懂题目的意思，不知道题目想让我干嘛，所以只能去看参考代码
然后发现原来是写一个类叫我自己实现单链表功能，通过虚拟头节点对创建的链表进行添加删除查找
我感觉还挺简单，就是对于自己写单链表这个功能感到有点懵，毕竟要自己重新构造一个类
自己先构造一个类来模拟链表节点，然后通过添加和删除扩充链表，头一次理解到原来链表的本质就是节点连接，只要有一个节点，就能弄成无限的节点
"""
class ListNode:
    def __init__(self, val = 0, next = None):
        self.val = val
        self.next = next

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

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index < 0 or index >= self.size:
            return -1

        cur = self.vir_head.next
        for i in range(index):
            cur = cur.next

        return cur.val

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

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

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

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

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if index < 0 or index >= self.size:
            return

        cur = self.vir_head # 找index前面的节点就用虚拟节点，找index节点就用虚拟节点的下一个节点即vir_head.next
        for i in range(index):
            cur = cur.next
        cur.next = cur.next.next
        self.size -= 1

203.反转链表

这题其实主要在于思路，思路到位了也很简单

"""
这个算法的关键在于，利用一个pre指针来记录当前循环到的节点，先用tmp变量记录下当前cur.next，然后把pre赋值给cur节点的next,最后更新pre达成循环
本来是有双指针的思路的，写着写着就变成了暴力，然后超时，hh
"""
class Solution(object):
    def reverseList(self, head):
        pre = None
        cur = head

        while cur != None:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp

        return pre

今天比较赶，就这样吧