训练营Day 3 : 203.移除链表元素 || 707.设计链表 || 206.反转链表

203.移除链表元素

首先回顾链表，我现在刷题还是使用python 进行，链表的基本概念是熟悉的，但是python 链表却很少使用过。

#Definition for singly-linked list.
#下面是定义一个单链表，
#dummmy_node = ListNode(next = head)  这个dummy_node的val是 0的,next 指向之后的链表
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

移除链表元素 方案一 当然是最直观的遍历整个链表了，空间复杂度O(1) ,时间复杂度O(n).

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dummy_node = ListNode(next = head)  # 定义了虚拟头结点，可以方便之后的处理
        cur_node = dummy_node   #遍历时头结点的指针应该是不动的，定义一个临时指针cur_node

        while (cur_node.next !=None):
            print(cur_node.next.val,'||',cur_node.val)
            if cur_node.next.val  == val:
                cur_node.next = cur_node.next.next
            else:
                cur_node = cur_node.next
        return dummy_node.next  #这里因为定了虚拟头指针，那么最后返回时应该也是返回虚拟头指针的next

方案二 是看了一些解读分析后，其实可以使用递归去做，链表也是很天然的使用递归去做；

但是整个方案看着很简洁，对于内存的占用看后面结果会比较大一些

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        # 这就是递归的终止条件，当一遍一遍递归，到最后一个尾巴结点，递归终止            
        if head == None:  
            return head 
        head.next = self.removeElements(head.next, val)
        return head if head.val != val else head.next

707.设计链表

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

class MyLinkedList(object):
    def __init__(self):
        self.head = Node()
        self.size = 0 
        print(self.head)
        print(self.head.val,  '||', self.head.next)

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        print('---------Get---------')
        if index < 0 or index >= self.size:
            print('Index is not exist!!!')
            return -1
        
        cur = self.head.next
        while(index):
            cur = cur.next 
            index -=1
        return cur.val

    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        print('---------addAtHead---------')
        new_node = Node(val)
        new_node.next = self.head.next  # 还是考虑用了虚拟头结点
        """
        #这两行是没想到的，当增加新结点后，头结点的指针应该要指向new_node,因为最后还是在原始结点上进行增加的
        """
        self.head.next = new_node  
        self.size +=1 

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        print('---------addAtTail---------')
        new_node = Node(val)
        cur = self.head
        while(cur.next):
            cur = cur.next
        cur.next = new_node
        #new_node.next =None #这一行可以删除,因为在定义新结点时，已经设置了模型next指针是指向None的
        self.size +=1
        
    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        print('---------addAtIndex---------')
        if index <0:
            self.addAtHead(val)
            return
        if index == self.size:
            self.addAtTail(val)
            return
        if index > self.size:
            print('Index is not existing!!!')
            return

        new_node = Node(val)
        cur = self.head
        while index:
            cur = cur.next
            index -=1
        new_node.next = cur.next
        cur.next =new_node
        self.size +=1
        

    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        print('---------addAtIndex---------')
        if index < 0 or index >= self.size:
            print('Index is not existing!!!')
            return
        
        cur = self.head
        while index:
            cur = cur.next
            index -=1
        cur.next = cur.next.next
        self.size -=1

206.反转链表

双指针yyds

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        pre = None
        cur = head

        while(cur != None):  # 终止条件也需要注意的 cur不断向后，要走完最后一个
            temp = cur.next  #因为cur->next指向要变动了，提前临时保存下一个结点
            cur.next = pre  # 将cur的next指向pre 完成反转

            pre = cur # 此时pre 指针向后走
            cur = temp # cur指针也需要移动
        return pre

python里面这个链表的写法确实很少用过，虽然给出了输入是 [1,2,3,4,5]，但是实际上的基于结构体的定义还是链表，具有链表的一系列属性；