老师，我如果跳过这章直接去看数据分析，这个影响会很大吗

老师我这个代码感觉和视频里的是同一个意思，但是运行就会报错，麻烦老师帮我看下

def quick_sort(nums):
    if len(nums) >= 2:
        index = len(nums)//2
        left,right = [],[]
        nums.remove(nums[index])
        for d in nums:
            if d < nums[index]:
                left.append(d)
            else:
                right.append(d)
        return quick_sort(left) + list(nums[index]) + quick_sort(right)
    else:
        return nums

if __name__ == "__main__":
    nums = [10,1,35,61,89,36,55]
    print(quick_sort(nums))

定义虚拟头节点时用的Node（-1），是不是用Node（1）也可以，目的就是为了占掉数据区，使这个虚拟节点只能用来指位置，到时候用的人就会觉得自己保存数据的那个节点才是第一个节点？

def quick_sort(args):

    if len(args) == 1:

        return args

    min = args[len(args)//2]

    left = [x for x in args if x < min]

    right = [x for x in args if x > min]

    return kuai_su(left) + [min] +kuai_su(right)

def quick_sort(args):

    if len(args) == 1:

        return args

    min = args[len(args)//2]

    left = [x for x in args if x < min]

    right = [x for x in args if x > min]

    return kuai_su(left) + [min] +kuai_su(right)

老师，为啥 数组长度的判断是等于1再返回数组 他会报越界的错

为什么只有revers__iter__()有用到Node里面的__str__方法，显示了Node：加名字的信息，也没有看到对__str__方法的调用，为什么会显示出其中的格式啊

老师这里是什么问题呢，我按照教程输入， link重新命名也提示出现问题，然后__init__也还需要赋值

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())
  为什么他运行不了

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 Array:
    def __init__(self, size=4):
        self.__size = size
        self.__item = [None] * size
        self.__length = 0

    def __setitem__(self, key, value):
        self.__item[key] = value
        self.__length += 1

    def __getitem__(self, key):
        return self.__item[key]

    def __len__(self):
        return self.__length

    def __iter__(self):
        for value in self.__item:
            yield value


class Slot:
    def __init__(self, key=None, value=None):
        self.key = key
        self.value = value

    def __str__(self):
        return 'key:{},value:{}'.format(self.key, self.value)


class HashTable:
    def __init__(self):
        self.size = 4
        self.items = Array(self.size)

    def find_index(self, key):
        index = self.get_index(key)
        if self.items[index] == None:
            return index
        else:
            while self.items[index] is not None:
                if self.items[index].key == key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return index

    def get_index(self, key):
        return hash(key) % self.size

    def put(self, key, value):
        s = Slot(key, value)
        index = self.get_index(key)
        self.items[index] = s

    def find_key(self, key):
        index = self.get_index(key)
        if self.items[index] == None:
            return None
        else:
            while self.items[index] is not None:
                if key == self.items[index].key:
                    return index
                else:
                    index = (5*index+1) % self.size
            return None

    def get(self, key):
        index = self.find_key(key)
        return self.items[index]


if __name__ == '__main__':
    h = HashTable()
    h.put('name', '王凯')
    h.put('sex', '男')
    h.put('age', '18')

    print(h.get('name'))
    print(h.get('age'))
    print(h.get('sex'))

错误情况：

正确情况：

ListNode:
    (, val: ):
        .val: = val  .next: ListNode | = MyLinkedList:
    ():
        .size = .head = ListNode()  (, index: , val: ):
        index > .size:
            index = (, index)
        add_node = ListNode(val)
        pred = .head
        _ (index):
            pred = pred.next
        add_node.next = pred.next
        pred.next = add_node
        .size += (, val: ) -> :
        .add_at_index(, val)

    (, val: ) -> :
        .add_at_index(.size, val)

    (, index: ) -> :
        index < index >= .size:
            -pred = .head
        _ (index + ):
            pred = pred.next
        pred.val

    (, index: ) -> :
        index < index >= .size:
            pred = .head
        _ (index):
            pred = pred.next
        pred.next = pred.next.next
        .size -= ():
        cur = .head.next  cur:  (cur.val)
            cur = cur.next  __name__ == :
    link=MyLinkedList()
    link.add_at_tail()
    link.add_at_tail()
    link.add_at_tail()
    link.add_at_tail()

老师  我怎么打印不出结果

老师，我是照着你的代码的逻辑写的，为什么你的运行没出问题，我的运行出问题了，麻烦帮忙看下，谢谢！

class Array():
    def __init__(self,size=4):
        self.__size = size # 记录容器大小
        self.__item = [None]*size #分配空间
        self.__length = 0

    def __setitem__(self,key,value):
        self.__item[key] = value
        self.__length += 1

    def __getitem__(self,key):
        return self.__item[key]
    
    def __len__(self):
        return self.__length
    
    def __iter__(self):
        for value in self.__item:
            yield value


class Slot():
    def __init__(self,key=None,value=None,next=None):
        self.key = key
        self.value = value
        self.next = next
    
    def __str__(self):
        return 'key:{},value:{}'.format(self.key,self.value)
    
class HashTable():
    def __init__(self,size=4):
        self.size = size
        self.item = Array(self.size)
    
    def get_index(self,key):
        return hash(key) % self.size
    
    def push(self,key,value): # 存放数据
        s = Slot(key,value)
        index = self.get_index(key)  # # 获取默认的索引位置
        if self.item[index] == None: # 索引位置是空的
            self.item[index] = s
        else: # 索引位置是非空的
            if self.item[index].key == key: # 所占空间的数据的key 与 传入数据 key 相同
                self.item[index].value = value 
            else: # 所占空间的数据的key 与 传入数据 key 不相同
                temp_next = self.item[index].next # 记录下一个节点
                while temp_next is not None:
                    if temp_next.key == key:
                        temp_next.value = value # 更新原来节点的数据
                        return
                    temp_next = temp_next.next # 继续往下移动一个节点
                temp_next = s
    
    def get(self,key): # 获取数据
        index = self.get_index(key) # 获取key对应的索引
        if self.item[index]: # 索引位置不为空
            if self.item[index].key == key:  # 索引位置的key 与 传入数据 key 相同
                return self.item[index].value # 获取索引位置的key对应的value
            else:
                temp_next = self.item[index].next # 记录下一个节点
                while temp_next is not None: # 下一个节点不为空
                    if temp_next.key == key:
                        return temp_next.value # 找到则获取
                    temp_next = temp_next.next  # 未找到则继续往下移动一个节点
                return None
        return None

if __name__ == "__main__":
    h = HashTable()
    h.push('name','吕布')
    h.push('sex1','男')
    h.push('sex2','女')
    h.push('sex3','保密')

    print(h.get('name'))
    print(h.get('sex3'))
    print(h.get('sex2'))
    print(h.get('sex1'))
    # print(h.get('age'))

运行截图：

else:

            # 从尾节点开始遍历

            succ = self.tail

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

                # 找到后继节点

                succ = succ.pre

            # 找到前驱节点

            pred = succ.pre

for _ in range(self.size,self.size-index,-1)

从后往前遍历不应该这么写吗