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

老师这个课后作业的怎么实现啊？我只实现了删除功能，给的参考链接里也找不到在哪，麻烦老师给下答案，谢谢老师

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)

老师我很疑惑，Class Node里只有个value和next 就算是给next赋值之后，p.next 为什么总是有值，就是为什么总是能知道下一个是啥，通过下一个视频插入数据后的数据存在了哪里，我就看到了赋值操作，没看到储存的操作

老师，我想求出二叉树中两个节点的距离，我的代码如下，函数已经写出来了，但是不知道如何返回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)

如果往链表中间插值我看p.next=temp_node 意思是给要插入的节点插入值，那这个节点本来的值就会向后挪，是不是需要一个p.next.next=temp_node.next? 而且 这些值互相赋值之后 存在了哪里？

删除指定索引元素也要和堆底元素互换吗

老师这个是不是多余的呢

for row in self.adj_matrix:

                row.append(0)

这句话不明白，一开始矩阵没有数据，

self.adj_matrix.append([0]*len(self.vertexes))

添加一个【0】*1，=》【【0】】

row.append(0),不还是原样吗，为啥就变成2*2了

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

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

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

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

代码敲完为什么这个self给我报错了？。。。。。。。。

     for _ in range(index+1):

   for _ in range(self.size-index):

这两个不都是正数吗  为什么遍历的不一样

# 拼接剩余数据

    result += left[l:]

    result += right[r:]

如果左面的比右面的小进入到数组里，右面的数还没比较就直接进数组里吗

想问下删除为什么运行效率高，比如一个列表，你要删除中间一个元素，那后面的元素不是要全部往前移一位。还是说删除之后那个位置就空在那里了，其他元素位置不变。