老师这集口误有点多哦，//不是取整吗，但是一直在说取余

老师你好，它的渐进上界为什么是3*n^2，而不是n^2呢

class LinkNode:

    def __init__(self,val:int) :

        self.val:int=val

        self.pre=None

        self.next=None

class Double_Queue_Linklist:

    def __init__(self) :

        self.head=LinkNode(0)

        self.tail=LinkNode(0)

        self.head.next=self.tail

        self.tail.pre=self.head

        self.size=0

    def push_first(self,val:int)->None:

        #从队首入队

        add_Node=LinkNode(val)

        add_Node.pre=self.head

        add_Node.next=self.head.next

        self.head.next=add_Node

        self.head.next.pre=add_Node

        self.size+=1

    def push_last(self,val:int)->None:

        #队尾入队

        add_Node=LinkNode(val)

        add_Node.pre=self.tail.pre

        add_Node.next=self.tail

        self.tail.pre.next=add_Node

        self.tail.pre=add_Node

        self.size+=1

    def length_Queue(self)->int:

        #队列长度

        return self.size

    def IsNull(self)->bool:

        #判断队列是否为空

        return self.size==0

    def pop_first(self)->int:

        #删除队首元素

        a=self.head.next

        self.head.next=a.next

        a.next.pre=self.head

        a.next=None

        a.pre=None

        self.size-=1

        return a.val

    def pop_last(self)->int:

        #删除队尾元素

        a=self.tail.pre

        a.pre.next=self.tail

        self.tail.pre=a.pre

        a.pre=None

        a.next=None

        self.size-=1

        return a.val

    def to_list(self):

        #队列转化为列表

        traver_head=self.head

        list1=[]

        for i in range(self.size):

            traver_head=traver_head.next

            list1.append(traver_head.val)

        return list1

    def top(self):

        #访问队首元素

        if self.size==0:

            raise Exception("队列为空")

        return self.head.next.val

if __name__=='__main__':

    a=Double_Queue_Linklist()

    a.push_first(1)

    a.push_first(2)

    a.push_last(3)

    a.push_first(5)

    print(a.to_list())

    a.pop_first()

    # print(a.to_list())

    print(a.length_Queue())

    print(a.top())

 为什么他的val会显示没有属性，应该怎么改让to_list方法运行

class Double_Queue_Linklist:
    def __init__(self) :
        self.head=LinkNode(0)
        self.tail=LinkNode(0)
        self.head.next=self.tail
        self.tail.pre=self.head
        self.size=0
       
    def push_first(self,val:int)->None:
        #从队首入队
        add_Node=LinkNode(val)
        add_Node.pre=self.head
        add_Node.next=self.head.next
        self.head.next=add_Node
        self.head.next.pre=add_Node
        self.size+=1
       
    def push_last(self,val:int)->None:
        #队尾入队
        add_Node=LinkNode(val)
        add_Node.pre=self.tail.pre
        add_Node.next=self.tail
        self.tail.pre.next=add_Node
        self.tail.pre=add_Node
        self.size+=1
       
    def length_Queue(self)->int:
        #队列长度
        return self.size
   
    def IsNull(self)->bool:
        #判断队列是否为空
        return self.size==0
   
    def pop_first(self)->int:
        #删除队首元素
        a=self.head.next
        self.head.next=a.next
        a.next.pre=self.head
        a.next=None
        a.pre=None
        self.size-=1
        return a.val
   
    def pop_last(self)->int:
        #删除队尾元素
        a=self.tail.pre
        a.pre.next=self.tail
        self.tail.pre=a.pre
        a.pre=None
        a.next=None
        self.size-=1
        return a.val
   
    def to_list(self):
        #队列转化为列表
        traver_head=self.head
        list1=[]
        for i in range(self.size):
            traver_head=traver_head.next
            list1.append(traver_head.val)
        return list1
   
    def top(self):
        #访问队首元素
        if self.size==0:
            raise Exception("队列为空")
        return self.head.next.val
   
if __name__=='__main__':
    a=Double_Queue_Linklist()
    a.push_first(1)
    a.push_first(2)
    a.push_last(3)
    a.push_first(5)
    # print(a.to_list())
    a.pop_first()
    # print(a.to_list())
    print(a.length_Queue())
    print(a.top())
  为什么他运行不了

为什么运行平台不一样，运行时间不一样？用同样型号的机子不可以吗？

老师，数组就是列表，为什么还要怎么写，为什么不直接用Python列表中的方法

  self.list_ = [list() for _ in range(self.len)] 
这句代码是创建了一个列表还是创建了多个列表

self.elments = [0]*(k+1)
#这里说的牺牲一个空间去判断是否为空意思是牺牲的这个空间用来存放return返回的值吗

 for i in range(size//2,-1,-1)

如果最后的一层不是满的二叉树，那size//2不就不准确了么

你好，请问这个leetcode无法登录是怎么回事啊， 谢谢

"双链表"

class Node:

    def __init__(self, val) -> None:

       # 当前节点值

       self.val = val

       # 下一个节点

       self.next = next

       # 上一个节点

       self.prev = None

class MyLinkedList:

    def __init__(self):

        "循环"

        self.head = Node(-1)

        self.tail = Node(-1)

        # 让伪头节点的下一个节点是 伪尾节点

        self.head.next = self.tail

        # 让伪尾节点的下一个节点是 伪头节点

        self.tail.next = self.head

        self.size = 0

    def get(self,index: int) -> int:

        # 判断index是否有效

        if index < 0 or index > self.size:

            return -1

        curr = self.getNode(index)

        return curr.val

    def getNode(self,index:int) -> Node:

        # 判断index的值是否过了1半的索引

        if index < self.size//2:

            # 如果索引小于1半值，从头查找速度快一些

            curr = self.head # 获取头信息

            for i in range(index+1):

                curr = curr.next

        else:

            # 如果索引大于1半值，从尾查找速度快一些

            curr = self.tail # 获取尾信息

            for i in range(self.size - index):

                curr = curr.prev

        return curr

    def addAtHead(self, val: int) -> None:

        self.addNode(self.head,self.head.next,val)

    def addAtTail(self, val: int) -> None:

        self.addNode(self.tail.prev,self.tail,val)

    def addAtIndex(self, index: int, val: int) -> None:

        # 判断index是否有效

        if index > self.size:

            return

        if index < 0:

            index = 0

        # 找到要哪个节点前增加数据

        curr = self.getNode(index)

        # 增加节点

        self.addNode(curr.prev,curr,val)

    def addNode(self,first:Node,second:Node,val:int) -> None:

        # 创建一个新节点

        temp_node = Node(val)

        # 创建的下一个节点是second

        temp_node.next = second

        # 原第二个节点的上一节更新为 新创建的节点

        second.prev = temp_node

        # 第一个节点的下一个节点更新为 创建新节点

        first.next = temp_node

        # 新创建的节点的上一个节点 更新原第一个节点

        temp_node.prev = first

        # 更新节点数

        self.size += 1

    def deleteAtIndex(self, index: int) -> None:

        # 判断index是否有效

        if index < 0 or index > self.size:

            return

        # 获取要删除的节点

        curr = self.getNode(index)

        # 修改要删除节点的上一个节点的关系

        curr.prev.next = curr.next

        # 修改要删除节点的下一个节点的关系

        curr.next = curr.prev

        # 更新节点数

        self.size -= 1

老师您好，请问这个错要怎么改正？

老师，根据两两排序，7个数字，第一轮应该是6次吧老师

为什么是质数，还是没想通老师

老师这个是不是多余的呢

老师，请问这个optional，List 指的是啥，为何要从typing里导入呢

还有这个判断遍历结束的条件如何理解呢