代码:

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吗？

老师,这个知识点我没能理解,我不明白图中位置的 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]调试的时候，我仍然对这个代码每一步运行到哪儿，返回什么结果感到很头疼，能否麻烦老师帮忙画个图清晰地展示一下。