删除父节点时Python二叉树不移动子节点

所以我有这个代码：

import random

randomList = []
randomListSize = 10


class Node:

    def __init__(self, rootValue):
        self.data = rootValue
        self.left = None
        self.right = None


class Tree:

    def createNode(self, data):
        return Node(data)

    def insertNode(self, node, data):
        if node is None:

            # Create root node

            return self.createNode(data)

        # Root node already exists

        if data < node.data:

            # New node data is less than root node

            node.left = self.insertNode(node.left, data)
        elif data > node.data:

            # New node data is bigger than root node

            node.right = self.insertNode(node.right, data)

        # Save new node data

        return node

    def searchNode(self, node, data):
        if node is None or node.data == data:

            # Node is found

            return node
        elif node.data > data:

            # Node may be to the left of the root

            return self.searchNode(node.left, data)
        elif node.data < data:

            # Node may be to the right of the root

            return self.searchNode(node.right, data)
        else:

            # Node is not found

            return None

    def deleteNode(self, node, data):
        if self.searchNode(node, data) is None:
            print "Node doesn't exist"
            return None
        else:

            # Node exists

            if data < node.data:
                node.left = self.deleteNode(node.left, data)  # DELETED NODE IS STILL RETURNED
            elif data > node.data:
                node.right = self.deleteNode(node.right, data)
            elif data == node.data:

                # Node has no children

                if node.left is None and node.right is None:
                    del node
                    return None
                elif node.left is None:

                # Node has 1 child

                    temp = node.right
                    node = None
                    return temp
                elif node.right is None:
                    temp = node.left
                    node = None
                    return temp
                else:

                    # Node has 2 children so find inorder successor

                    temp = self.inorderSuccessor(node.right)
                    node.data = temp.data
                    if temp.right is not None:
                        temp = temp.right
                    print node.right.left.data

    def inorderSuccessor(self, node):
        while node.left is not None:
            node = node.left
        return node

    def preorder(self, node):

        # Root then left sub-tree then right sub-tree

        if node is not None:
            print node.data
            self.preorder(node.left)
            self.preorder(node.right)

    def inorder(self, node):

        # Left sub-tree then root then right sub-tree

        if node is not None:
            self.inorder(node.left)
            print node.data
            self.inorder(node.right)

    def postorder(self, node):

        # Left sub-tree then right sub-tree then root

        if node is not None:
            self.postorder(node.left)
            self.postorder(node.right)
            print node.data


def setup():
    randomList = []
    for i in range(randomListSize):
        randomList.append(random.randint(1, 100))
    print randomList
    randomList = [
        59,
        90,
        93,
        23,
        60,
        85,
        64,
        23,
        15,
        15,
        ]
    print randomList
    tree = Tree()
    root = tree.insertNode(None, randomList[0])  # Create root node
    for i in range(len(randomList) - 1):
        tree.insertNode(root, randomList[i + 1])  # Create each child node
    return (tree, root)


def traverse():
    while True:
        try:
            user = \
                int(input('1 for preorder, 2 for inorder and 3 for postorder: '
                    ))
            if user == 1:
                tree.preorder(root)
            elif user == 2:
                tree.inorder(root)
            elif user == 3:
                tree.postorder(root)
            else:
                print 'Invalid choice'
        except ValueError:
            print 'Invalid choice'
        break


if __name__ == '__main__':
    (tree, root) = setup()
    while True:
        try:
            userChoice = \
                int(input('Enter 1 to add a node, 2 to search for a node, 3 to delete a node and 4 to traverse the tree: '
                    ))
            if userChoice == 1:
                newNode = int(input('Enter a number: '))
                tree.insertNode(root, newNode)
            elif userChoice == 2:
                userSearch = int(input('Enter a number: '))
                if tree.searchNode(root, userSearch) is not None:
                    print (userSearch, 'exists')
                else:
                    print "Node doesn't exist"
            elif userChoice == 3:
                removeNode = int(input('Enter a number: '))
                tree.deleteNode(root, removeNode)
            elif userChoice == 4:
                traverse()
            else:
                print 'Invalid choice'
        except ValueError:
            print 'Invalid choice'

随机导入
随机列表=[]
randomListSize=10
类节点：
def uuu init uuu（self，rootValue）：
self.data=rootValue
self.left=无
self.right=无
类树：
def createNode（自身，数据）：
返回节点（数据）
def insertNode（自身、节点、数据）：
如果节点为无：
#创建根节点
返回self.createNode（数据）
#根节点已存在
如果数据<节点数据：
#新节点数据少于根节点
node.left=self.insertNode（node.left，数据）
elif data>node.data：
#新节点数据大于根节点
node.right=self.insertNode（node.right，数据）
#保存新节点数据
返回节点
def searchNode（自身、节点、数据）：
如果node为None或node.data==数据：
#找到节点
返回节点
elif node.data>数据：
#节点可能位于根的左侧
返回self.searchNode（node.left，数据）
elif node.data<数据：
#节点可能位于根的右侧
返回self.searchNode（node.right，数据）
其他：
#找不到节点
一无所获
def deleteNode（自身、节点、数据）：
如果self.searchNode（节点，数据）为无：
打印“节点不存在”
一无所获
其他：
#节点存在
如果数据<节点数据：
node.left=self.deleteNode（node.left，数据）#删除的节点仍会返回
elif data>node.data：
node.right=self.deleteNode（node.right，数据）
elif data==节点数据：
#节点没有子节点
如果node.left为无，node.right为无：
德尔节点
一无所获
elif node.left为无：
#节点有1个子节点
temp=node.right
节点=无
返回温度
elif node.right为无：
temp=node.left
节点=无
返回温度
其他：
#节点有2个子节点，因此按顺序查找后续节点
temp=自索引接受器（右节点）
node.data=temp.data
如果temp.right不是无：
温度=右侧温度
打印node.right.left.data
def inorderSuccessor（自身，节点）：
而node.left不是无：
node=node.left
返回节点
def预订单（自身、节点）：
#根，然后左子树，然后右子树
如果节点不是“无”：
打印节点数据
self.preorder（节点左）
self.preorder（node.right）
def索引器（自身，节点）：
#左子树然后根然后右子树
如果节点不是“无”：
self.inoder（node.left）
打印节点数据
self.inoder（node.right）
def后订单（自身、节点）：
#左子树然后右子树然后根
如果节点不是“无”：
self.postorder（节点左）
self.postorder（node.right）
打印节点数据
def设置（）：
随机列表=[]
对于范围内的i（随机列表大小）：
randomList.append（random.randint（1100））
打印随机列表
随机列表=[
59,
90,
93,
23,
60,
85,
64,
23,
15,
15,
]
打印随机列表
tree=tree（）
root=tree.insertNode（无，随机列表[0]）#创建根节点
对于范围内的i（len（randomList）-1）：
tree.insertNode（根，随机列表[i+1]）#创建每个子节点
返回（树、根）
def traverse（）：
尽管如此：
尝试：
用户=\
int（输入（'1表示前序，2表示内序，3表示后序：'
))
如果用户==1：
树。前序（根）
elif user==2：
目录树索引（根）
elif user==3：
树。postorder（根）
其他：
打印“无效选择”
除值错误外：
打印“无效选择”
打破
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
（树，根）=设置（）
尽管如此：
尝试：
用户选择=\
int（输入（'输入1添加节点，输入2搜索节点，输入3删除节点，输入4遍历树：'
))
如果userChoice==1：
newNode=int（输入（'输入一个数字：'））
tree.insertNode（根，新节点）
elif userChoice==2：
userSearch=int（输入（'输入一个数字：'））
如果tree.searchNode（root，userSearch）不是None：
打印（用户搜索“存在”）
其他：
打印“节点不存在”
elif userChoice==3：
removeNode=int（输入（'输入一个数字：'））
tree.deleteNode（根，removeNode）
elif userChoice==4：
导线测量（）
其他：
打印“无效选择”
除值错误外：
打印“无效选择”

当我有两个子节点并试图查找顺序继承节点时，我的错误出现在

deleteNode（）

中。我可以这样做，然后用后继节点的内容替换目标节点，但它不会向上移动后继节点的所有子节点，而是让它创建两个重复节点

任何想法，谢谢