ch2_2 python_设计 单链表, 增加，删除节点， 查找或删除元素

lc707

https://leetcode.cn/problems/design-linked-list/

python 使用单链表的设计

关键点：

1. 需要设置哨兵节点作为 伪头节点， 伪头节点的设置， 方便统一函数的实现：

即 当存在伪头 节点时：
插入或删除头节点处， 函数的实现方法 == 插入或删除非头节点处， 函数的实现方法

2. 伪头节点 不能作为 链表的 主体成分， 因此， 真正的头节点 是伪头节点后面的那个节点， 作为 index ：0

3. 在节点 index 前， 插入节点A：
关键点是， 找到 插入节点A时，
A的 先驱节点是谁？ A 的后继节点是谁？

4. 删除节点

1 单向链表的实现

# single linkList

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

class MyLinkedList:

    def __init__(self):  # 总共两个属性值；
        # 设计的链表中，需要一个伪头节点， 作为哨兵节点； 
        # 统计个数的属性；
        self._size = 0  
        self._dummy_head = ListNode(val=0, next=None)


    def get(self, index: int) -> int:
        if index <0 or index >= self._size:
            return -1

        cur_node = self._dummy_head  # 当前节点是从伪头节点开始的；
        
        for _ in range(index +1): #  总共执行了 （index+1）步，因为是从伪节点开始走的，所以需要多走一步
           cur_node = cur_node.next
        

        return cur_node.val



    def addAtHead(self, val: int) -> None:
        
        return self.addAtIndex(0,val)

    

    def addAtTail(self, val: int) -> None:
        return self.addAtIndex(self._size,val)



    def addAtIndex(self, index: int, val: int) -> None:
            if index >self._size:
                return 

            pred = self._dummy_head # pred 找到待插入节点的前一个节点；

            for _ in range(index):  #  注意，此时index 取不到，故是index 的前一个节点；
                pred = pred.next
            
            add_node = ListNode(val)  # 初始化一个待插入的节点；

            # 这里注意顺序，分配好， 先分配好插入节点的下一个节点；再分配先驱节点的下一个节点；  否则，会导致插入节点的后续节点为null;
            add_node.next = pred.next
            pred.next = add_node

            self._size = self._size + 1



    def deleteAtIndex(self, index: int) -> None:
          if index >=self._size:
                return 
          if index  < 0: index = 0

          pred = self._dummy_head

          for _ in range(index ):  #  总共走了 index 步骤，
             pred = pred.next     # 结束时，到达待删除节点的前一个节点；
        
          # 分配好
          pred.next = pred.next.next

          self._size = self._size - 1 



    def removeElements(self, target: int) -> None:

        cur = self._head

        while(cur != None):          #  注意取 cur, 当最后一个循环时， cur 为尾节点了，  cur = cur.next 后， 此时 cur = None;

            if cur.next.val == target:
                cur.next = cur.next.next
                self._count -= 1

            cur  = cur.next

        return

    def traversal(self, )-> None:
        cur = self._head

        cur = cur.next
        while(cur != None):   #  注意取 cur, 当最后一个循环时， cur 为尾节点了，  cur = cur.next 后， 此时 cur = None;
            print(cur.val)
            cur = cur.next


if __name__ == "__main__":
       list1 = [2, 2, 3, 5, 9, 6]

       obj1 = SingleLinkList()

       for i in range(len(list1)-1, -1, -1 ):
          # print( list1[i])
          obj1.addAtIndex(0,list1[i])

       print(" the original list ")
       obj1.traversal()

       print(" \n *** after add at index  \n ")
       obj1.addAtIndex(3, 88)
       obj1.traversal()
       print(" \n *** after add at tail \n ")
       obj1.addAtTail(99)
       obj1.traversal()

       print(" \n *** after remove the elements  \n ")
       obj1.removeElements(99)
       obj1.traversal()
       print("get index 4 :", obj1.get(4))