老师您好，我在运行这个程序的时候，有时候会报错但有时候又是好的，不知道是个什么情况……

程序：

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

错误情况：

正确情况：

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

老师，讲课过程中用来画图的这个软件是什么？

老师，我想求出二叉树中两个节点的距离，我的代码如下，函数已经写出来了，但是不知道如何返回level值，麻烦您帮我改一下，谢谢您了

class BiTNode:
    def __init__(self):
        self.data = None
        self.lchild = None
        self.rchild = None

def arraytotree(arr,start,end):
    #中序遍历生成二叉树
    root = None
    if end >= start:
        root = BiTNode()
        mid = (start+end+1)//2
        root.data = arr[mid]
        root.lchild = arraytotree(arr,start,mid-1)
        root.rchild = arraytotree(arr,mid+1,end)
    else:
        root = None
    return root

def FindParentNode(root,node1,node2):
    #找到公共父节点
    if root == None or root == node1 or root == node2:
        return root
    lchild = FindParentNode(root.lchild,node1,node2)
    rchild = FindParentNode(root.rchild,node1,node2)
    if lchild == None:
        return rchild
    elif rchild == None:
        return lchild
    else: return root

def printTree(root,node,level=1):
    #输出节点与根节点的距离level

    if root == node:
        return 0
    if root.lchild != None:
        if root.lchild == node:
            print(level)
        printTree(root.lchild,node,level=level+1)
    # print(root.data,end=" ")
    if root.rchild != None:
        if root.rchild == node:
            print(level)
        printTree(root.rchild,node,level=level+1)

if __name__=="__main__":
    arr = [1,2,3,4,5,6,7,8,9,10]
    root = arraytotree(arr,0,len(arr)-1)
    node1 = root.rchild.lchild.lchild
    node2 = root.lchild.rchild.lchild
    L = printTree(root,node1)
    M = printTree(root,node2)
    res = FindParentNode(root,node1,node2)
    N = printTree(root,res)
    print(L,M,N)
    distance = printTree(root,node1)+printTree(root,node2)-2*printTree(root,res)
    # if res != None:
    #     print(str(node1.data))
    #     print(str(node2.data))
    #     print(str(res.data))
    # print(distance)

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

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

老师，如果1变成3，23变成2，要删除12的话，把2提到了12的位置，现在2的左子树是4，右子树是41，那不是两个子树都大于2了吗？这还符合规则吗？不是说左子树小于父节点，右子树大于父节点吗？谢谢老师

代码中left和right事一个列表得意思？

视频中是通过eumerate函数，去遍历枚举类型中的每个下标和值，为什么我通过遍历列表的下标去查找对应的index 的方法总是找不到呢？不知道问题出在哪里？为什么这种方法不行？

"""
线性查找方法
"""
def linear_search(find_value, argus):
    for index in range(len(argus)):
        if find_value == argus[index]:
            return index
        else:
            return -1


if __name__ == '__main__':
    nums = [1,2,3,5,6,7,8,9,14,23,34,56,42,64]
    print(linear_search(7, nums))

结果：

我认为视频中有两处错误：

1.在定义bubble_sort(array)时:

if num[j]>num[j+1]:
    num[j], num[j+1] = num[j+1], num[j]

此时应该是用的形参，所以不是实参num，而应该是array.

if array[j]>array[j+1]:
    array[j], array[j+1] = array[j+1], array[j]

2. 在进行最优优化时，认为运行了i 次，这个应该不对

print("比较了{}次".format(i))

而i 是从0起始的， 所以应该是运行了i+1次

print("比较了{}次".format(i+1))

老师，线性结构扩容为什么要重新分配空间，不能在原来空间后面继续移位呢？

老师，在截图中红线圈出的这行代码是不是多余了？

视频中代码有错误，测试结果不正确，没有维持最大堆的特性。

红框部分的逻辑没看明白，root是定义的一个空节点，如果root没有数据的时候，在root的下一个节点增加数据，如果有数据，在最后一个节点增加数据，为什么self.next.next = node就是指最后一个节点？self.next = node 是什么意思？root有指向哪里了？能否画个内存图说明一下数据是怎么存进去的。

class Node():
    def __init__(self,value=None,next=None):
        self.value = value 
        self.next = next    def __str__(self):
        return 'Node:{}'.format(self.value)class LinkedList():
    def __init__(self):
        self.root = Node()
        self.size = 0 #记录有多少元素
        self.next = None  #增加新数据时，将新数据的地址与谁关联

    def append(self,value):
        node = Node(value)        # 判断是否已经有数据
        if not self.next: #如果没有节点时
            self.root.next = node #将新节点挂到root后面
        else:
            self.next.next = node #将新节点挂到最后一个节点上
        self.next = node
        self.size += 1
    def append_first(self,value):
        node = Node(value)        if not self.next:
            self.root.next = node
            self.next = 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        if current:            while current is not self.next:                yield current.value
                current = current.next            yield current.value    def find(self,value):
        for v in self.__iter__():            if v == value:                return True
    def find2(self,value):
        current = self.root.next        if current:            while current is not self.next:                if current.value == value:                    return current
                current = current.next    def remove(self,value):
        current = self.root.next        if current:            while current is not self.next: 
                if current.value == value:
                    temp.next = current.next                    del current
                    self.size -= 1
                    return True
                temp = current
                current = current.nextif __name__ == "__main__":
    link = LinkedList()
    link.append('孙悟空')
    link.append('猪八戒')
    link.append_first('唐僧')    for v in link:
        print(v)    # print(link.find('孙悟空'))
    # print(link.find('六儿猕猴'))
    # print(link.find2('孙悟空'))
    # print(link.find2('六儿猕猴'))
    print('-'*30)
    link.remove('孙悟空')    for v in link:
        print(v)

老师，你这代码这块

存在巨大的问题，只有删除中间数据的时候不报错，删除第一个的时候会显示temp没有定义，最后一个怎么也删除不了，好好看看，然后课程改进一下吧，容易误导人