设计链表-python

设计链表-力扣

思路

单链表

• get(index)
  cur=虚拟头结点，for循环的range(index+1)，才能到真实的index所指向的元素；
  注意边界处理：索引无效，index<0或index>=size，返回-1

• addAtHead(val)
  初始化新节点，newNode.next=虚拟头结点.next，即指向None;
  接着虚拟头结点.next=newNode；
  最后size+1；

• addAtTail(val)
  初始化新节点，先让cur=虚拟头结点，for循环到现在的尾结点，range(size)；
  接着cur.next=新节点；
  最后size+1；

• addAtIndex(index,val)
  特殊处理：
  1）index<0时，统一index=0,表示在表头加元素；
  2）index=size是有效的，表示在表尾加元素；index>size是无效的，不插入，return空；
  首先初始化新节点，让cur=虚拟结点，pre=None，for循环找到index对应的元素cur和对应index前面的元素pre，range(index+1)，pre,cur=cur,cur.next；
  接着pre.next=新节点，新节点.next=cur
  最后size+1

• deleteAtIndex(index)
  特殊处理：
  1）index>=size或index<0，索引无效，返回空
  首先让pre=None,cur=虚拟头结点，for循环找到index对应的元素cur和index前面的元素pre
  接着pre=cur.next,cur.next=None,切断指针关联
  最后size-1

#定义链表类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val=val
        self.next=next


class MyLinkedList:

    def __init__(self):
        #虚拟头结点
        self._dummyHhead=ListNode(0)
        #计数
        self._size=0


    def get(self, index: int) -> int:
        #若索引无效，返回-1
        if (index >= self._size) or (index < 0):
            return -1
        cur=self._dummyHhead
        for _ in range(index+1):
            cur=cur.next
        return cur.val


    def addAtHead(self, val: int) -> None:
        #在表头插入结点，新节点就是新的头结点
        newNode=ListNode(val)
        newNode.next=self._dummyHhead.next
        self._dummyHhead.next=newNode
        self._size+=1



    def addAtTail(self, val: int) -> None:
        #在表尾插入结点
        newNode=ListNode(val)
        cur=self._dummyHhead
        for _ in range(self._size):
            cur=cur.next
        cur.next=newNode
        self._size+=1



    def addAtIndex(self, index: int, val: int) -> None:
        #若index大于链表长度，不插入
        if index > self._size:
            return
        
        #若index小于0，则在头部插入结点
        if index < 0:
            index=0
        
        newNode=ListNode(val)
        cur=self._dummyHhead
        pre=None
        #若index等于链表长度，该结点加到链表尾        
        for _ in range(index+1):
            pre,cur=cur,cur.next
        newNode.next=cur
        pre.next=newNode
        self._size+=1
        


    def deleteAtIndex(self, index: int) -> None:
        #若索引无效，返回空
        if (index >= self._size) or (index < 0):
            return
        cur=self._dummyHhead
        pre=None
        for _ in range(index+1):
            pre,cur=cur,cur.next                  
        pre.next,cur.next=cur.next,None
        self._size-=1