老师，这里存放的时候出现冲突就可以找到下一个位置放，但如果这时把第一个数据删掉，那第二个数据要找的时候先找第一个位置，第一个位置因为删掉所以是空，返回也是空，是不是就找不到了

第二个问题，这里找下一个位置是不是可以用递归去找呢

老师您好，这块的知识我一直不是特别熟，我自己缕了一下，麻烦您看下我想的是不是对的呢？

# 数据结构：哈希表，使用二次探查方法解决哈希冲突的问题

# 先创建数组
class Array(object):
    def __init__(self,size=5):
        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 v in self._item:
            yield v

    def delitem(self,key):
        if self._item[key]:
            self._item[key]=None
        else:
            print('本身无数据')

# 创建存储到哈希表的对象类型
class Solt():
    # 初始化方法
    def __init__(self,key=None,value=None):
        self.key = key
        self.value = value
    # 打印对象
    def __str__(self):
        return f'key : {self.key},value : {self.value}'

# 创建哈希表数据结构,此方法存在哈希冲突
class HashTable():
    # 初始化方法 生成固定长度的哈希表
    def __init__(self):
        self.size = 4
        self.item = Array(self.size)

    # 获取哈希索引的方法
    def get_index(self,key):
        return hash(key) % self.size

    # 插入数据时查找哈希地址是否被占用，返回为空的地址索引
    def find_indexToPut(self,key):
        # 获取输入的key对应的索引值
        index = self.get_index(key)
        if self.item[index] == None:
            return index
        else:
            # 循环判断索引对应的对象的分支
            while self.item[index] is not None:
                if self.item[index].key == key:
                    return index
                else:
                    index = (5 * index + 1) % self.size
            return index

    # 放入哈希表数据
    def put(self,key,value):
        s = Solt(key,value)
        index = self.find_indexToPut(key)
        self.item[index] = s

    # 获取哈希表数据时，先判断索引对应位置存储的对象
    def find_index(self,key):
        index = self.get_index(key)
        # 循环判断索引对应的对象的分支
        if self.item[index] == None:
            return None
        else:
            # 循环判断索引对应的对象的分支
            while self.item[index] is not None:
                if self.item[index].key == key:
                    return index
                else:
                    index = (5 * index + 1) % self.size
            return None

    # 获取哈希表数据
    def get(self,key):
        # 判断获取的index
        index = self.find_index(key)
        return self.item[index]



if __name__ == '__main__':
    ht = HashTable()
    ht.put('name','我的老伙计')
    ht.put('sex', '男')
    ht.put('age', 18)
    ht.put('work', '程序员')
    ht.put('name', '北京')  # 超出哈希表的容量，陷入死循环了
    # ht.put('money', 1000)
    print(ht.get('name'))
    print(ht.get('sex'))
    print(ht.get('age'))
    print(ht.get('work'))
    # print(ht.get('home'))

为什么self.next和self.root还会有next属性?

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

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

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

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

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

class Node():
    def __init__(self, value=None,prev=None, next=None):
        self.value = value
        self.prev = prev
        self.next = next
    def __str__(self):
        return 'Node:{}'.format(self.value)
class DoubleLinkList():
    def __init__(self):
        self.root = Node()
        self.end = None
        self.size = 0

    def append(self, value):
        node = Node(value)
        # 判断是否存在数据
        if not self.end:   # 如果不存在元素
            self.root.next = node   # 将root的下一个节点，设置为新的node节点
            node.prev = self.root   # 将node新节点的上一节点设置为root
        else:
            self.end.next = node   # 将原来的最后一个节点设置为新的node节点
            node.prev = self.end   # 将新的node节点的 上一节点设置为原来的最后一个节点
        self.end = node    # 更新最后一个节点为新加的node节点
        self.size += 1

    def append_first(self, value):
        node = Node(value)
        #判断是否存在数据
        if not self.end:
            self.end = node  # 将新节点设置为最后一个节点
        else:
            temp = self.root.next   # 先保存原来的第一个节点
            node.next = temp    # 新节点的 下一个节点 设置为 原来的第一个节点
            temp.prev = node   # 原来第一个节点的 上一个节点 设置为 新的节点
        node.prev = self.root   # 设置新的节点的上一节点为 root节点
        self.root.next = node   # 将新的节点挂在root上
        self.size += 1
    
    def __iter__(self):
        current = self.root.next
        if current:
            while current is not self.end:
                yield current.value
                current = current.next
            yield current.value

    def revers_iter(self):
        current = self.end    # 获取最后一个节点
        if current:
            while current is not self.root:
                yield current
                current = current.prev
        
    def remove_first(self):
        if self.end:    # 如果存在节点
            temp = self.root.next    # 获取第一个节点
            self.root.next = temp.next    # 把第二个节点设置为root 的下一个节点
            if temp.next:       # 如果存在第二个节点
                temp.next.prev = self.root   # 第二个节点的 上一个节点为root
            return temp
class Queue():
    def __init__(self, size=4):
        self.item = DoubleLinkList()
        self.size = size
        self.length = 0
    def put(self, value):
        self.item.append(value)
        self.length += 1
    def pop(self, value):
        if self.length <= 0:
            return 'Null'
        self.length -= 1
        return self.item.remove_first()
    def empty(self, value):

if __name__ == "__main__":
    q = Queue()
    q.put('嫦娥')
    q.put('唐三藏')
    q.put('天蓬元帅')

    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())

老师帮我看看这是什么错误？自己也查了，概率一下，挺蒙的！

"双链表"

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

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

看到这里  想加深了解一下魔术方法，有点懵了，没有进行调用，只是单纯的打印a1[0]这种，也能达到预期的效果，再有，yield的用法，也要再了解一下

老师，位运算这里 2左移一位空间变成4，4左移一位空间变成8 ，找了一下资料感觉还是不懂，请问老师有没有好一点的链接可以分享一下？

老师，本节课的代码pop方法只是提供了返回值，但并没有删除内容，如果要是继续pop的话还是会弹出之前的内容。

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 Queue:
    def __init__(self,size=4):
        self.__item = Array(size)
        self.size = size
        self.head = 0
        self.end = 0    
    def put(self,value):
        self.__item[self.head]= value
        self.head += 1
        if self.head == self.size:
            self.head = 0
   
    def pop(self):
        temp = self.__item[self.end]
        self.end += 1
        if self.end == self.size:
            self.end = 0
        return temp

if __name__ == '__main__':
    q = Queue()
    q.put('唐三藏')
    q.put('孙悟空')
    q.put('猪八戒')
    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())
    print(q.pop())

代码:

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
    def __getitem__(self, key):
        return self.__item[key]
    def __iter__(self):
        for i in self.__item:
            yield i
class Heap():
    def __init__(self):
        self.item=Array(8)
        self.count=0
    def add(self,value):
        self.item[self.count]=value
        self.setup(self.count)
        self.count += 1
    def setup(self,index):
        if index>0:
            parent=int((index-1)/2)
            if self.item[parent]<self.item[index]:
                self.item[parent],self.item[index]=self.item[index],self.item[parent]
                self.setup(parent)
    def pop(self,index=0):
        if self.count<=0:
            return None
        else:
            value = self.item[0]
            self.count -= 1
            self.item[0] = self.item[self.count]
            self.item[self.count] = None
            self.setdown(0)
            return value
    def setdown(self,index):
        left=index*2+1
        right=index*2+2
        largest=index
        if right<self.count:
            if self.item[largest]<self.item[right] and self.item[right]>self.item[left]:
                largest=right
            elif self.item[largest]<self.item[right] and self.item[right]<self.item[left]:
                largest=left
            elif self.item[largest]>self.item[right] and self.item[largest]<self.item[left]:
                largest=left
        elif left<self.count:
            if self.item[left]>self.item[largest]:
                largest=left
        if largest !=index:
            self.item[largest],self.item[index]=self.item[index],self.item[largest]
            self.setdown(largest)
heap=Heap()
heap.add(10)
heap.add(15)
heap.add(20)
# heap.pop(20)
heap.pop(10)
for i in heap.item:
    if i:
        print(i)

运行结果:

老师请问一下，为什么我最大堆删除10以后，再打印，结果还是会显示10?我不是已经把10删除了吗？那么这样结果不应该是20和15吗？

没有最短路径和最小生成树算法