刷题第三天——203.移除链表元素 707.设计链表 206.反转链表

● 203.移除链表元素

虚拟头指针的思想和循环条件是重中之重

第一种方法：
分两种情况： 如果是头节点的话，就把head = head.next
如果不是头节点就定义一个指针= head，指针代表检测的节点的前一个节点。

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        # 第一种方案：分两种情情况
        # 头指针不是None并且头指针的值是target
        while head != None  and head.val == val:
            head = head.next
        # tmp 代表当前的listnode的上一个
        # 初始化tmp，确保head不能是val
        tmp = head
        # tmp不是none并且写一个不是none以防有空指针访问的问题发生
        while tmp != None and tmp.next!= None:
            if tmp.next.val == val:
                tmp.next = tmp.next.next
            else:
                tmp = tmp.next
        return head

第二种方法：
插入一个虚拟的头指针在head前面，然后把current 变量等于这个虚拟的头指针。

返回的时候返回虚拟头指针的next

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        # 第二种方案：虚拟头指针
        vir = ListNode()
        vir.next = head

        tmp = vir
        # tmp不是none并且写一个不是none以防有空指针访问的问题发生
        while tmp != None and tmp.next!= None:
            if tmp.next.val == val:
                tmp.next = tmp.next.next
            else:
                tmp = tmp.next

        return vir.next

● 707.设计链表

处理边界条件的时候一定要注意举一个极端的例子

本题包含5个函数：分别是

获取第n个节点
尾部插入节点
头部插入节点
第n个节点插入元素
删除第n个节点

获取第n个节点的时候要注意：

设置一个虚拟头节点这样的好处就是可以确保后面其他的操作是相同的。
其次一点就是在遍历整个链表的过程中要注意声明一个current指针，这样就不会把头节点带跑偏

头部插入节点：

有一个坑就是：
在插入节点的过程中。如果前一个节点指向新的节点。再把新的节点指向原来的头节点，就会出现无法获取原来的头节点的问题。
所以我们要更改这个顺序才行。所以我们要先把新节点指向原来的头节点。再把虚拟节点指向新节点。

尾部插入节点：

让current找到尾部节点，这个边界条件：current.next == NULL

第n个节点前插入一个节点：
我一定要让current节点指向第n-1个位置
还有一个问题就是和插入头节点的顺序一致

删除第N个节点：
和上面的思路类似.

class Node:
    def __init__(self, value):
        self.val = value
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        # 定义一个虚拟头节点
        self.vir_head = Node(0)
        self.count = 0        


    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index in range(self.count):
            cur = self.vir_head

            while index > 0 :
                cur = cur.next
                index -= 1
            return cur.next.val
        else:
            return -1



    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """

        n_head = Node(val)
        n_head.next = self.vir_head.next
        self.vir_head.next = n_head

        self.count += 1



    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        cur = self.vir_head
        while(cur.next != None):
            cur = cur.next
        n_tail = Node(val)
        cur.next = n_tail

        self.count += 1



    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """ 
        if index > self.count:
            return -1
        elif index < 0 :
            index = 0

        cur = self.vir_head
        while index > 0 :
            cur = cur.next
            index -= 1
        n_node = Node(val)
        n_node.next = cur.next
        cur.next = n_node
        self.count += 1




    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if index not in range(self.count):
            return -1
        cur = self.vir_head
        while index > 0 :
            cur = cur.next
            index -= 1
        cur.next = cur.next.next
        self.count -= 1


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

206.反转链表

双指针解法注意不要使用虚拟头节点，不然会有圈圈list
前面的指针初始化成None就好了
注意while循环的限制条件

# 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
        """
        a = None
        b = head
        while b != None:
            tmp = b.next
            b.next = a
            a = b
            b = tmp

        return a