if self.count > right:

            if self.item[right] > self.item[left] and self.item[right] > self.item[laget]:

                laget = right

            elif self.item[left] > self.item[right] and self.item[left] > self.item[laget]:

                laget = left

        elif left < self.count:

            if self.item[left] >self.item[index]:

                laget = left

        if laget != index:

            self.item[index],self.item[laget] = self.item[laget],self.item[index]

            self.siftdown(laget)

老师，为什么 右节点不能等于长度呢

老师，请问这个通过返回self._list如何判断是否为空呢

问题在代码里了

'''
建立单链表，并进行添加元素
'''

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

    def append(self,value):
        node = Node(value)
        if not self.next:
            self.root.next = node
        else:
            self.next.next = node
        self.size += 1
        self.next = node

    def append_first(self,value):
        '''
        最初
        root -> 1
        我理解的:
        2 -> root -> 1 (2为新增元素)
        如果是这样的话  可代码表示的就不一样了
        代码：
        root -> 2 -> 1
        很久没看书了，忘记了这一块的根节点用法了，是不是所谓的根节点root就是一个空，一个指针？
        '''
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            tmp = self.root.next
            self.root.next = node
            node.next = tmp
        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_first('扁鹊')
    link.append_first('蔡文姬')

    for v in link:
        print(v)

老师，我有几个问题没搞懂：

1、视频中.next的作用是啥

2、

“新节点的下一个节点”指的是“新节点的指针域”吗？，它指向“前驱节点的下一个节点”指的是“前驱节点的指针域”吗？但这里不应该指向“后驱节点的下一个节点”吗？

3、这个for _ in range()其实就是for i in range()对吧？

老师这集口误有点多哦，//不是取整吗，但是一直在说取余

后边试着加了几个删除的方法，指点一波，其中有一块不太确定，代码中写了

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

    def append(self,value):
        node = Node(value)
        if not self.next:
            self.root.next = node
        else:
            self.next.next = node
        self.size += 1
        self.next = node

    def append_first(self,value):
        '''
        最初
        root -> 1
        我理解的:
        2 -> root -> 1 (2为新增元素)
        如果是这样的话  可代码表示的就不一样了
        代码：
        root -> 2 -> 1
        很久没看书了，忘记了这一块的根节点用法了，是不是所谓的根节点root就是一个空，一个指针？
        '''
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            tmp = self.root.next
            self.root.next = node
            node.next = tmp
        self.size += 1

    def remove_first(self):
        if not self.root.next:
            print('no node in link')
            pass
        else:
            '''
            最初：
            root -> 蔡文姬 -> 扁鹊 —> 阿珂
            删除头节点：
            root  -> 扁鹊 —> 阿珂
            '''
            self.root.next = self.root.next.next
            self.size -= 1


    def remove(self):
        '''
        从最后删除
        '''
        if not self.root.next:
            print('remove no node in link')
            pass
        else:
            current = self.root
            while current.next is not self.next:
                current = current.next
            self.next = current
            self.next.next = None
            self.size -= 1

    def remove_value(self,value):
        '''
        删除指定元素
        '''
        if not self.root.next:
            print('remove_value no node in link')
            pass
        else:
            if self.next.value == value:
                self.remove()
            elif self.root.next.value == value:
                self.remove_first()
            else:
                current = self.root.next
                while current.next.value != value:
                    current = current.next
                current.next = current.next.next
                self.size -= 1



    def remove_size(self,key):
        '''
        删除指定位置
        :param key: an int
        '''
        if key > self.size:
            print('size not enough')
        elif key == 1:
            self.remove_first()
        elif key == self.size:
            self.remove()
        else:
            '''
            感觉这一块不太对，但又不知道怎么搞
            '''
            current = self.root
            current_num = 1
            while current_num != key:
                current = current.next
                current_num += 1
            current.next = current.next.next
            self.size -= 1

    def __iter__(self):
        if not self.root.next:
            print('no node in link')
            pass
        else:
            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_first('扁鹊')
    link.append_first('蔡文姬')
    # link.remove_first()
    # link.remove_first()
    # link.remove()
    # link.remove_value('蔡文姬')
    link.remove_size(2)

    for v in link:
        print(v)

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

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

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

p = .head
i (index):
    p = p.next
    
      p.next = p.next.next
     # 这部分代码有问题，需要修改一下。
     
# 下面这部分代码是正确的, ^-^&& ^-^
          
# 获取隐藏的头节点
p = self.head
# 获取要删除的节点的上一个节点
for i in range(index):
    # 获取要删除的节点
    p = p.next
    #
    if i == index - 1:
        p.next = p.next.next

res = []

    def pre_order(root):

        # 判断root是否为空

        if not root:

            return

        else:

            # 获取根节点的值

            res.append(root.item)

            # 遍历左子树

            pre_order(root.left)

            # 遍历右子树

            pre_order(root.right)

    pre_order(root)

    return res

递归这还是有点不明白，遍历左子树玩后再遍历右子树

class Node():
    """
    树结构
    """
    def __init__(self, datas, left, right):
        self.datas,self.left, self.right = datas, left, right

class Tree():
    def __init__(self, root = None):
        self.root = root
    def init_data(self, datas):
        node_dict = {}

        # 封装树节点
        for d in datas:
            node = Node(d['data'], d['left'], d['right'])
            node_dict[d['data']] = node
        # 根据节点关系 填充数据 
        for d in datas:
            node = node_dict[d['data']]
            if node.left:
                node.left = node_dict[node.left]
            if node.right:
                node.right = node_dict[node.right]
            if d['is_root']:
                self.root = node

    def search(self, subtree, value):
        if subtree is None:
            return None
        elif subtree.data > value:
            return self.search(subtree.left, value)
        elif subtree.data < value:
            return self.search(subtree.right, value)
        else:
            return subtree

if __name__ == '__main__':
    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},
]


    tree = Tree()
    tree.init_data(node_list)

    print(tree.search(tree.root, 41).data)
    # print(tree.search(tree.root, 55))

老师，请您帮忙看看是哪里错了，查了半天没找见

为什么运行平台不一样，运行时间不一样？用同样型号的机子不可以吗？

老师，这个遍历数据的时候iter好像并没有实现什么功能，把他给注释了在主函数里直接打印也可以实现遍历的效果

视频中是通过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))

结果：

老师，我根据课堂的讨论，把代码改动了一下，发现删除值为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)

运行结果如下：