代码随想录day3

第一题

设置虚拟头节点，在删除、增加节点n，指针要找到前一个节点n-1。从虚拟头节点开始遍历，while条件为current.next（此时current指向最后一个节点）

class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dummy_head=ListNode(next=head)
        node = dummy_head
        while node.next:
            if  node.next.val==val:
                node.next=node.next.next
            else:
                node=node.next
        return dummy_head.next

第二题

1.增删查改指针的开始位置不同

2.设置self.size变量

3.判断条件，举例子，然后取反

4.while 判断条件与cur其实位置匹配，从dummy_head开始为cur-1

5.for循环次数的判断

极端情况法

画图法：判断指针移动的次数，与index的关系

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

class MyLinkedList(object):

    def __init__(self):
        self.dummy_head=LinkNode()
        self.size = 0                   #在init中定义size 

    def get(self, index):
        if index<0 or index>=self.size: #判断极端情况下的实际意义 index=0 size=1
            return -1

        current= self.dummy_head.next  # get函数， cur指针从真实head开始遍历
        for i in range(index):       # range(n)，可以代表执行了n次操作。判断方式，
        # 1.极端情况，index=0 ，current不移动，不进入循环。2 画图，看index和curr移动到相应位置执行操作的次数的关系                           
            current=current.next

        return current.val

    def addAtHead(self, val):
        
        self.dummy_head.next=LinkNode(val,self.dummy_head.next)
        self.size+=1

    def addAtTail(self, val):
 
        current= self.dummy_head
        #增删改，从虚拟头指针开始遍历。只有找到index节点前的index-1节点，才能修改index节点
        while current.next:#停止的条件是最后一个元素指向None
            current=current.next
        current.next=LinkNode(val)
        self.size+=1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index<0 or index>self.size:#这里没有=号，size=1，index可以取[0,1],index<=size，取反
            return
         #增删改，从虚拟头指针开始遍历。只有curr指向index-1节点，才能修改index节点
        current= self.dummy_head
        for i in range(index):
             # 1.极端情况，index=0 ，current不移动，不进入循环。2 画图，判断index和curr移动到相应位置执行操作的次数的关系(curr应从dummy_head移动到index-1节点，执行index次位移)     
            current=current.next
        current.next=LinkNode(val,current.next)
        self.size+=1

    def deleteAtIndex(self, index):
        if index<0 or index>=self.size: #size=5，index[0,4],index<size,取反
            return
        current= self.dummy_head
        for i in range(index):
            current=current.next
        current.next=current.next.next
        self.size-=1

第三题

双指针，cur起始位置为head，pre其实为none。每次循环，1.temp存储cur下一个元素。2.反向链接 3.移动位置    直到cur为None

# 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
        """
        cur=head
        pre=None

        while cur:
            temp=cur.next
            cur.next=pre
            pre=cur
            cur=temp
        return pre

递归法。

递归函数：

1.递归停止条件

2.记录cur.next，反向链接

3.进入下一步递归

# 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):
        return self.reverse(head,None)
    def reverse(self,cur,pre):
        if cur==None:
            return pre
        temp=cur.next
        cur.next=pre
        return self.reverse(temp,cur)