链表<新>

 class Node:
     '''
     节点类
     链表节点结构  data    next
     data: 节点保存的数据
     _next: 保存下一个节点对象
     '''

     def __init__(self, data, pnext=None):
         self.data = data
         self._next = pnext

     def __repr__(self) -> str:
         return str(self.data)

 class Link_list:
     """
     链表类:
         属性: 1.链表头head  2.链表长度
         方法: 1.是否为空 isEmpty 2.增加 append 3.删除节点 delete 4.修改(更新)节点 update
               5.查找节点 getNode  6.获取节点的索引 getIndex  7.插入 insert  8.清空链表clear
      """

     def __init__(self) -> None:
         """
         初始化链表,head信息为空,长度为0
         """
         self._head = None
         self._length = 0

     def isEmpty(self):
         """
         判断链表是否为空
         :return:
         """
         return self._length == 0

     def append(self, item):
         """

         :param item: Node 或者 node的data信息
         :return: None
         """

         if not isinstance(item, Node):
             item = Node(data=item)

         if not self._head:
             # head为Node对象
             # head --->  data + nextNode
             self._head = item
             self._length += 1
         else:
             # 取到第一个的Node对象
             _node = self._head
             # 如果不是最后一个节点则一直往下找,使用while的原因是不知道会有多少个
             while _node._next:
                 # 得到后继为空的,也就是最后一个
                 _node = _node._next
             # 将新的节点赋值给最后一个的_next属性
             _node._next = item
             self._length += 1

     def insert(self, index, item):
         if not isinstance(item, Node):
             item = Node(data=item)
         if not isinstance(index, int):
             raise TypeError("index应该为int类型")
         if index < 0 or index >= self._length:
             print("输入的索引不正确")
             return False
         if index == 0:
             # 在链表的头部进行添加
             old_head = self._head
             item._next = old_head
             self._head = item
             self._length += 1

         else:
             # 得到第一个node
             _node = self._head
             for i in range(index - 1):
                 # 得到插入位置的前驱
                 _node = _node._next
             # 得到本来在指定位置的node
             old_index_node = _node._next
             # 给插入的node设置前驱
             _node._next = item
             # 给插入的元素设置后继
             item._next = old_index_node
             self._length += 1
         return True

     def delete(self, index):
         """
         根据索引删除节点
         :param index: 索引
         :return: bool
         """
         if not isinstance(index, int):
             raise TypeError("index应该为int类型")
         if self.isEmpty():
             print("当前链表为空")
             return False
         if index < 0 or index >= self._length:
             print("输入的索引不正确")
             return False
         elif index == 0:
             self._head = self._head._next
             self._length -= 1
             return True
         elif index == self._length - 1:
             _node = self._head
             # 如果不是最后一个节点则一直往下找
             for i in range(index):
                 _node = _node._next
             _node._next = None
             self._length -= 1
             return True
         else:
             _node = self._head
             for j in range(index - 1):
                 _node = _node._next
             _node._next = _node._next._next
             self._length -= 1
             return True

     def pop(self,index=None):
         """

         :type int
         :param index:
         :return:
         """
         # 先判断链表是否是空的
         if self.isEmpty():
             print("当前链表为空")
             return False
         if  index is None:
             # 不指定index的时候,直接弹出最后一个
             index = self._length-1
         if not isinstance(index, int):
             raise TypeError("index应该为int类型")
         if index < 0 or index >= self._length:
             print("输入的索引不正确")
             return False
         # 获取head指向的node
         first_node = self._head
         _node = first_node
         for i in range(index-1):
             # 得到第index-1个位置的node
             _node = _node._next

         if index==0:
             self._head=first_node._next
             self._length-=1
             return first_node
         else:
             select_node = _node._next
             _node._next= select_node._next
             self._length-=1
             return select_node

     # def pop(self, index):
     #     """
     #     根据索引删除节点,并返回
     #     :param index: 索引
     #     :return: bool
     #     """
     #     if not isinstance(index, int):
     #         raise TypeError("index应该为int类型")
     #     if self.isEmpty():
     #         print("当前链表为空")
     #         return False
     #     if index < 0 or index >= self._length:
     #         print("输入的索引不正确")
     #         return False
     #     elif index == 0:
     #         """弹出第一个node"""
     #         # 得到第0个node
     #         _node = self._head
     #         # 将head指向第二个node
     #         self._head = _node._next
     #         self._length -= 1
     #         return _node
     #     elif index == self._length - 1:
     #         """弹出最后一个node"""
     #         # 先找到head指向的node,即第0个node
     #         _node = self._head
     #         # 如果不是最后一个节点则一直往下找
     #
     #         for i in range(index - 1):
     #             # 拿到倒数第二个node
     #             _node = _node._next
     #         end_node = _node._next
     #         # 给倒数第二个node设置新的后继,None
     #         _node._next = None
     #         self._length -= 1
     #         return end_node
     #     else:
     #         # 中间的node
     #         _node = self._head
     #         for j in range(index - 1):
     #             # 得到指定index的前驱
     #             _node = _node._next
     #         # 得到应得的node
     #         selected_node = _node._next
     #         # 将弹出的node的前驱的后继设置成要弹出的node的后继
     #         _node._next = selected_node._next
     #         self._length -= 1
     #         return selected_node

     def getNode(self, index):
         """
         根据index得到节点
         :type int
         :param index: 索引
         :type: Node
         :return: Node对象
         """
         if not isinstance(index, int):
             raise TypeError("index应该为int类型")
         if self.isEmpty():
             print("当前链表为空")
             return False
         if index < 0 or index >= self._length:
             print("输入的索引不正确")
             return False
         # 得到第0个node
         _node = self._head
         for i in range(index):
             _node = _node._next
         return _node

     def update(self, index, data):
         """
         更新节点
         :param index: 索引
         :param data: 节点信息
         :return: 返回修改后的节点
         """
         if not isinstance(index, int):
             raise TypeError("index应该为int类型")
         if self.isEmpty():
             print("当前链表为空")
             return False
         if index < 0 or index >= self._length:
             print("输入的索引不正确")
             return False
         _node = self._head
         for i in range(index):
             _node = _node._next
         _node.data = data
         return _node

     def getIndex(self, node):
         """
         根据节点得到节点索引
         :param node:节点
         :return:index
         """
         if isinstance(node, Node):
             for i in range(self._length):
                 if node is self.getNode(i):
                     return i
             print("node异常")
             return
         else:
             raise TypeError("类型不正确")

     def clear(self):
         self.head = None
         self._length = 0
         return True

     def printl(self):
         for i in range(self._length):
             print(self.getNode(i))