Suzy找到实习了吗Day 3 | 链表开始啦 203移除链表元素 707设计链表 206 反转链表

定义链表的结构

class ListNode:
    def __init__(self, val, next=None): #构造函数
        self.val = val
        self.next = next

尾部node.next=None，不是等于null

203移除链表元素

My trial（not ac）

我出现的问题是没有将规则分类好，所以处理边界问题或者一些特殊的cases会报错

Rule

针对链表移除问题

1. 对非头结点移除，需要将prenode.next->curnode.next
2. 对于头节点的移除，直接将head更新为head.next
3. 如果采取虚拟头结点的方式，则可以合并规则，因为任何结点（包含头结点）的删除都可以用规则1

Finally

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummyhead=ListNode(0,head)
        prenode=dummyhead
        curnode=dummyhead.next
        if(prenode.next==None):
            return head
        while(curnode!=None):
            number=curnode.val
            # print(curnode.val)
            if(number!=val):
                prenode=curnode #保存上一个node
                curnode=curnode.next #往前走一步
            else:
                #开始删
                if(curnode.next==None):
                    prenode.next=None
                    curnode=prenode.next
                else:
                    prenode.next=curnode.next
                    curnode=curnode.next
        return dummyhead.next     

1. number=curnode.val：必须要在判断了curnode!=none的情况下才可以取值
2. 最后的返回值是dummy.next，这样不管该数组是不是被删完了，都规则统一，如果没有被删完，dummyhead.next就是真正的head，如果被删完了，dummyhead.next=none，即空链表。

707设计链表

一开始没有自己定义node的数据类型，所以不知道怎么下手。看了解析

My trial

#define my node
class Node:
    def __init__(self, val, next=None): #构造函数
        self.val = val
        self.next = next
class MyLinkedList:
    def __init__(self):
        #因为下面有删除操作，所以设置了一个虚拟结点
        self.dummyhead=Node(0,None)
        self.count=0
    def get(self, index: int) -> int:
        if(index<0 or index>self.count-1):
            return -1
        count=0
        node=self.dummyhead.next
        res=node.val
        if node==None:
            return -1
        while(count<index):
            count+=1
            node=node.next 
        return node.val

    def addAtHead(self, val: int) -> None:
        head=Node(val,None)
        head.next=self.dummyhead.next
        self.dummyhead.next=head
        self.count+=1
        
    def addAtTail(self, val: int) -> None:
        tail=Node(val,None)
        pointer=self.dummyhead
        while(pointer.next!=None):
            pointer=pointer.next
        pointer.next=tail
        self.count+=1
       
    def addAtIndex(self, index: int, val: int) -> None:
        if(index>self.count or index<0):
            #！！！！当index=count是就表示加在末尾 不应该返回
            return
        newnode=Node(val,None)
        pointer=self.dummyhead
        count=-1
        while(count<index-1):
            count+=1
            pointer=pointer.next
        newnode.next=pointer.next
        pointer.next=newnode
        self.count+=1
        

    def deleteAtIndex(self, index: int) -> None:
        if(index>self.count-1):
            return
        pointer=self.dummyhead
        count=-1
        while(count<index-1):
            count+=1
            pointer=pointer.next
        if pointer.next.next==None:
            pointer.next=None
        else:
            pointer.next=pointer.next.next
        self.count-=1
        
    def printlink(self):
        pointer=self.dummyhead.next
        while(pointer!=None):
            print(pointer.val)
            pointer=pointer.next
        
# 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)

好不容易，debug了好久好久

1. 一些边界情况一定要想到，比如add at index，当index不合法的时候，应该不做动作。但是index可以取边界，因为这样表示加在末尾
2. 一开始没有加self.count记录链表的长度，走了很多弯路。链表一定要初始化的两个参数：虚拟头结点，长度。

206 反转链表

一开始记录了3个指针，然后就晕了。

链表知识性错误！！！！big 错误！！！！

新的链表的尾部一定要设置tail.next=None
不然一直一直陷入死循环！！！！！！！！

感觉我用while(condition)经常出错

用while(True):
if(condition):
break
避免错误！！！