老师,这个知识点我没能理解,我不明白图中位置的 current 是如何放在循环里进行循环的? 他是什么原理?  我打印出来他们类型都不一样

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 DoubleLinkedList():
    def __init__(self):
        self.root = Node()
        self.size = 0
        self.end = None

    def append(self, value):
        node = Node(value)  # 封装节点对象
        # 判断是否已经有数据
        if not self.end:  # 如果没有节点
            self.root.next = node  # 将root的下一个节点 设置为新的node节点
            node.prev = self.root  # 设置新节点的上一个节点为root
        else:
            self.end.next = node  # 将原来最后节点的下一个节点 设置为新的node节点
            node.prev = self.end  # 将原来最后节点的上一个节点 设置为最后一个节点的节点
        self.end = node  # 更新最后 一个节点新加的节点
        self.size += 1

    def append_first(self, value):
        node = Node(value)
        # 判断是否已经连接数据
        if not self.end:  # 如果没有节点
            self.root.next = node  # 将root 节点的下一个节点设置为新的node节点
            node.prev = self.root  # 将新的bode节点的上一个节点 设置为root 节点
            self.end = node  # 更新最后一个新加的root节点
        else:
            temp = self.root.next  # 报讯原来的第一个节点
            node.next = temp  # 将新的node节点 的下一个节点 设置为原来的第一个的节点
            temp.prev = node  # 更新原来保存的第一个节点的上一个节点微信的node节点
        node.prev = self.root  # 将新的node节点 的上一个节点 设置为root节点
        self.root.next = node  # 将 root 节点间的下一个节点 设置为新的node节点
        self.size += 1

    def __iter__(self):
        current = 0
        print(type(current))
        print(type(self.end))
        if current:
            # print(dir(current))
            while current is not self.end:
                yield current.value
                current = current.next
                # print(current)
                print(type(current))
            yield current.value

    def revers_iter(self):
        current = self.end
        while current is not self.root:
            yield current
            current = current.prev
            print(current)
            print(dir(current))


if __name__ == "__main__":
    link = DoubleLinkedList()
    link.append('李白')
    link.append('貂蝉')
    link.append('王昭君')
    link.append('闵月')
    link.append('小乔')
    link.append_first('大乔')

    for v in link:
        print(v)
        
    print('*' * 10, '  返回节点 ', '*' * 10)
    
    for v in link.revers_iter():
        print(v)

老师下面视频中的代码（打框的）是不是重复了呀？ 我感觉只要两个条件就可以了呀！

if right<self.count:#存在右节点
    if self.item[right]>self.item[largest] and self.item[right] >self.item[left]:
        largest = right
     elif self.item[left]>self.item[largest] and self.item[left] >self.item[right]:
        largest = left

老师 代码中为什么是prev==None而不是prev=None？

result+=list(left[l:])
result+=list(right[r:])

老师我觉得这两句代码的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

    # 删除功能   
    def remove(self,value):
        for n in self.__iter__():
            if n==value:
                locate=self.__item.index(value)  # 找到删除的值所对应的索引
                del self.__item[locate]
            else:
                print('未找到值所对应的索引....')



if __name__ == "__main__":
    a1=Array()
    a1[0]='孙悟空'
    a1[1]='猪八戒'


    for v in a1:
        print(v)

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

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))

老师，算法与数据结构这章与前面的关联大吗？我因为个人原因想先学习这章

这段代码应该有大问题吧，代码表达的意思好像是当前链表为空的时候在空的root节点的的下一节点添加数据，此时做的不应该是将新数据添加进root节点当作链表的第一个节点吗？

老师我想问一下视频中

temp = temp_next
temp_next= temp.next

这两行代码应该是说占位置的key和传入的key不同就去找下一个节点，那为什么要写“temp = temp_next”不能直接写“temp_next = temp_next.next”吗，就是把视频中的这两行代码直接写成一句“temp_next = temp_next.next”不知道效果是否一样

老师你好，我想问一下“prev = n”这句怎么理解，n不是被删除了吗为什么还要把n赋给prev，如果n没被删除n赋给prev又有什么意义，我又在“remove_all”这个函数里尝试了一下去掉“prev = n”这句最后显示一个“Node:唐僧”这是为什么。另外希望老师早日康复

老师你好我想问一下，在 reverse_iter 方法中为什么循环完退出后没有 yield current.value 这一步

老师，我根据课堂的讨论，把代码改动了一下，发现删除值为12的节点后，tree.root.left变成了值为29的节点，未明白为什么会是这个结果，麻烦老师帮忙看一下，代码如下：

NODE_LIST = [
    {'data': 60, 'left': 12, 'right': 90, 'is_root': True},
    {'data': 12, 'left': 4, 'right': 41, 'is_root': False},
    {'data': 4, 'left': 1, 'right': None, 'is_root': False},
    {'data': 1, 'left': None, 'right': None, 'is_root': False},
    {'data': 41, 'left': 29, 'right': None, 'is_root': False},
    {'data': 29, 'left': 23, 'right': 37, 'is_root': False},
    {'data': 23, 'left': None, 'right': None, 'is_root': False},
    {'data': 37, 'left': None, 'right': None, 'is_root': False},
    {'data': 90, 'left': 71, 'right': 100, 'is_root': False},
    {'data': 71, 'left': None, 'right': 84, 'is_root': False},
    {'data': 100, 'left': None, 'right': None, 'is_root': False},
    {'data': 84, 'left': None, 'right': None, 'is_root': False},
]

class Node():
    def __init__(self,data=None,left=None,right=None):
        self.data,self.left,self.right = data,left,right
    
    def __str__(self):
        return f'数据是:{self.data}'

class Tree():
    def __init__(self,root=None):
        self.root = root

    def init_data(self,data_list):
        node_dict = {}
        for d in data_list:
            node = Node(d['data'],d['left'],d['right'])
            node_dict[d['data']] = node
        for d in data_list:
            node = node_dict[d['data']]
            if node.left:
                node.left = node_dict[d['left']]
            if node.right:
                node.right = node_dict[d['right']]
            if d['is_root']:
                self.root = node

    def search(self,subtree,value): # 查找 #subtree表示从哪个节点开始查找
        if subtree is None:
            return None
        elif subtree.data > value:
            return self.search(subtree.left,value) # 这里return不能少
        elif subtree.data < value:
            return self.search(subtree.right,value) # 这里return不能少
        else:
            return subtree

    def get_min(self,subtree): # 获取值最小的节点
        if subtree is None:
            return None
        elif subtree.left is None:
            return subtree
        else:
            return self.get_min(subtree.left)
    
    def get_max(self,subtree): # 获取值最大的节点
        if subtree is None:
            return None
        elif subtree.right is None:
            return subtree
        else:
            return self.get_max(subtree.right)
    
    def insert_data(self,subtree,value):
        if subtree is None:
            subtree = Node(value)
        elif subtree.data > value:
            subtree.left = self.insert_data(subtree.left,value) # 绑定节点关系，注意这句代码
        else:
            subtree.right = self.insert_data(subtree.right,value) # 绑定节点关系,注意这句代码
        return subtree

    def delete_data(self,subtree,value):
        if subtree is None:
            return None
        elif subtree.data > value:
            subtree.left = self.delete_data(subtree.left,value) # 找左分支删除，注意维持节点关系
            return subtree
        elif subtree.data < value:
            subtree.right = self.delete_data(subtree.right,value) # 找右分支删除，注意维持节点关系
            return subtree
        else: # 找到节点
            if subtree.left is None and subtree.right is None: # 要删除的是叶子节点
                return None
            elif subtree.left is None or subtree.right is None: # 要删除的节点只有1个分支
                if subtree.left is not None:
                    return subtree.left
                elif subtree.right is not None:
                    return subtree.right
            else: # 要删除的节点含有2个分支
                left_min_node = self.get_min(subtree.left) # 从要删除的节点的左分支中找到最小值
                right_min_node = self.get_min(subtree.right) # 从要删除的节点的右分支中找到最小值
                if left_min_node.data > right_min_node.data:
                    subtree.data = left_min_node.data
                    subtree.left = self.delete_data(subtree.left,left_min_node.data) # 从要删除的节点的左分支中删除值最小的节点,注意节点关系的维护
                else:
                    subtree.data = right_min_node.data
                    subtree.right = self.delete_data(subtree.right,right_min_node.data) # 从要删除的节点的右分支中删除值最小的节点,注意节点关系的维护
                return subtree

    def add(self,value): # 增加数据
        node = self.search(self.root,value) # 查找数据  是否已存在
        if node:
            return '该数据已存在'
        else:
            self.root = self.insert_data(self.root,value) # 绑定节点关系,注意这句代码
    
    def remove(self,value): # 删除数据
        node = self.search(self.root,value) # 查找数据  是否已存在
        if node is None:
            return '你要删除的数据不存在'
        self.delete_data(self.root,value)
    
    def tree_iter1(self,node): # 深度优先的遍历方法
        if node:
            print(node.data)
            self.tree_iter1(node.left)
            self.tree_iter1(node.right)

    def tree_iter2(self,node): # 广度优先的遍历方法
        node_list = [node]
        for n in node_list:
            print(n.data)
            if n.left:
                node_list.append(n.left)
            if n.right:
                node_list.append(n.right)

if __name__ == "__main__":
    tree = Tree()
    # tree.init_data(NODE_LIST)
    # print(tree.search(tree.root,41))
    # print(tree.search(tree.root,61))
    # print(tree.get_min(tree.root))
    # print(tree.get_max(tree.root))
    # tree.add(60)
    # tree.add(50)
    # tree.add(70)
    # tree.add(55)
    # tree.add(80)
    # print(tree.root)
    # print(tree.root.left)
    # print(tree.root.right)
    # print(tree.root.left.right)
    # print(tree.root.right.right)
    tree.add(60)
    tree.add(12)
    tree.add(90)
    tree.add(4)
    tree.add(41)
    tree.add(71)
    tree.add(100)
    # tree.add(1)
    tree.add(2)
    tree.add(29)
    tree.add(84)
    # tree.add(23)
    tree.add(3)
    tree.add(37)
    print(tree.root)
    print(tree.root.left)
    tree.remove(12)
    print(tree.root)
    print(tree.root.left)
    # tree.tree_iter2(tree.root)

运行结果如下：

node_ditct里面存储的是 key是data的名称， value是实例化的节点，

node_dict[node.left]为什么出来的是内存地址

老师，我能试着把这个归并排序的代码写出来，也能达到效果，但是比如以数列[10,1,35,61,89,36,55]调试的时候，我仍然对这个代码每一步运行到哪儿，返回什么结果感到很头疼，能否麻烦老师帮忙画个图清晰地展示一下。

老师，你写的find_key方法还有bug。

1. 在获取一个未设置的key时，运行结果可能显示None类型没有属性key

2. 在获取一个未设置的key时，可能陷入死循环

我修改后的代码如下：

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,size=4):
        self.size = size # 用来记录空间大小
        self.item = Array(self.size)
        self.length = 0 # 用来记录元素的个数
    
    def get_index(self,key):
        return hash(key) % self.size
    
    def find_index_to_insert(self,key):
        index = self.get_index(key) # 获取key对应的索引
        if self.item[index] == None: # 索引没被占用
            return index
        else:
            while self.item[index] is not None:
                if key == self.item[index].key: # 获取到相同的key
                    return index
                else:
                    index = (index*5+1) % self.size
            return index

    def push(self,key,value): # 存放数据
        index = self.find_index_to_insert(key)  # 获取key对应的索引
        self.item[index] = Slot(key,value)
        self.length += 1

    def find_key(self,key):  
        index = self.get_index(key) # 获取key对应的索引
        if self.item[index] == None:
            return None
        else:
            count = 0
            while self.item is not None: # 这里不能写成self.item[index] is not None
                # 判断查找的Key是否与item里的key相同，注意防止self.item[index]为空,否则报None类型没有属性key的错误
                if self.item[index] is not None and key == self.item[index].key:
                    return index
                else:
                    index = (index*5+1) % self.size
                    count += 1
                while count > self.size**self.length: # 解决死循环的问题
                    return None
            return None
    
    def get(self,key): # 获取数据
        index = self.find_key(key) # 获取key对应的索引
        if index is not None:
            return self.item[index]
        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'))  # 这里要解决陷入死循环的问题