这个在网站的哪个文件里参考，没找到，懵逼

def merge_sort(argss):
    if len(argss) <= 1:
        return argss
    count = int(len(argss) / 2)
    left = merge_sort(argss[:count])
    right = merge_sort(argss[count:])
    return merge(left, right)


def merge(left, right):
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += list(left[l:])
    result += list(left[r:])
    return result

if __name__ == '__main__':
    args = [10, 1, 35, 61, 89, 36, 55]
    print(merge_sort(args))

老师，我按照视频中打的，为啥结果是帮我看一下，在哪里错误了

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

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

老师，我感觉是照着你的代码写的，但是发现运行结果不对，我觉得是find_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)
    
    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)

    def find_key(self,key):
        index = self.get_index(key) # 获取key对应的索引
        if self.item[index] == None:
            return None
        else:
            while self.item is not None:
                if key == self.item[index].key: # 判断查找的Key是否与item里的key相同
                    return index
                else:
                    index = (index*5+1) % self.size
            return None
    
    def get(self,key): # 获取数据
        index = self.find_key(key) # 获取key对应的索引
        if index:
            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'))

运行结果：

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

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

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

解释一下视频里说的“下一次增加节点的时候往谁身上挂”

关于self.next=node

这个执行inorder(root.left)到最左节点后，最左节点的左节点不就是none了吗 这不直接触发if not root的return结束了吗 咋执行res.append和inorder(root.right)

十八十九分钟的时候听到了猫叫，感觉它应该是饿了

def put(self,key,val):
    '''添加数据'''
    # 判断是否需要扩容
    if self.load_factor() > self.load_thres:
        # 扩容
        pass

老师，这一步挺多余啊，即使需要扩容也已经在下面的extend函数扩容过了，这一步判断最终是pass,显得挺多余的

老师，我有个疑问：

上一节视频说的大O（也就是函数渐近上界）和这一节咋不一样啊。上一结中说的是2n^2+8n+5的渐近上界是3n^2，这里怎么时间复杂度取的又是n^2啊。

3n^2在n增长时恒大于2n^2+8n+5，这可以理解。忽略低次项保留最高项（去系数）也可理解，就是不明白啥时候取3n^2，啥时候取n^2啊

老师,这个知识点我没能理解,我不明白图中位置的 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)

class Node():
    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

class LinkList():
    def __init__(self):
        self.root = Node()  # 代表头
        self.size = 0  # 代表有几个数据
        self.next = None  # 通过设置next的值为0，来记录最后一个节点是谁，方便新加数据时，安排在那个元素后面
    
    def append(self, value):
        node = Node(value)  # 实例化
        # 判断是否已经有数据
        if not self.next: # 如果没有节点时
            self.root.next = node  # 将新节点挂到root后面
            self.next = node  # 因为self.next的值是None、node的next值是None，所以相当于node代替了self.next
        else:
            self.next.next = node  # 在最后一个节点的next指向node
            self.next = node  # 因为self.next的值是None、node的next值是None，所以相当于node代替了self.next
        self.size += 1
    def append_first(self,value):
        node = Node(value)  # 实例化
        if not self.next:  # 如果没有节点时
            self.root.next = node  # 直接在root后面加节点，相当于在头部加数据
            self.next = node  # 仅有node这一个数据，所以node也是最后一个节点
        else:
            temp = self.root.next  # 获取原来root后面的那个节点
            self.root.next = node  # 将新的节点挂到root上
            node.next = temp  # 新的节点的下一个节点是原来root后面的节点
        self.size += 1
    def __iter__(self):
        """遍历 """
        current = self.root.next
        while current is not self.next:
            yield current.value
            current = current.next
        yield current.value
if __name__ == '__main__':
    link = LinkList()
    link.append('孙悟空')
    link.append('猪八戒')
    link.append_first('唐僧')

    for i in link:
        print(i)

老师，请问红线处标注的理解是否正确？尤其是红色箭头处

    def add(self,value):
#         查找数据，是否已存在
        node = self.search(self.root,value)
        if node:
            return False
        else:
            self.root = self.insert_data(self.root,value)
            return True

老师，add函数中

self.root = self.insert_data(self.root,value)

作用是什么，这样添加新节点时，把self.root修改掉么？