Python 为了让树行走不起作用

我正在尝试用python实践BST树实现，下面是我的代码

import pdb

class Node():
    def __init__(self, parent=None, key=None):
        self.parent = parent if parent != None else None
        self.left = None
        self.right = None
        self.key = key if key != None else None

class BST():
    def __init__(self):
        self.root = Node() 

    def insertKey (self, key):
        #pdb.set_trace()
        # transverse till we find empty position
        if (self.root.key == None):
            self.root.key = key
        else:
            node = self.root
            while (node.left != None and node.right != None):
                if node.key < key:
                    node = node.right
                else:
                    node = node.left
            #we have node either left or right is empty
            if node.key < key:
                node.right = Node (node, key)
            else:
                node.left = Node (node, key)

    def inOrder (self, node):
        #pdb.set_trace()
        if node != None:
            self.inOrder (node.left)
            print node.key
            self.inOrder (node.right)

    def printLeft (self, node):
        if node != None:
            self.printLeft (node)
            print node.key

    def debugAll (self):
        self.inOrder (self.root)
        #self.printLeft (self.root)

    def fromArray (self, numbers):
        srt = sorted(numbers)
        print srt
        length = len(srt)
        mid = length/2
        rootEle = srt[mid]
        self.insertKey (rootEle)
        for i in range (1, mid+1):
            try:
                #pdb.set_trace()
                self.insertKey (srt[mid-i])
                self.insertKey (srt[mid+i])
            except IndexError:
                pass

bst = BST()
bst.fromArray ([1,2,4,3,6,5,10,8,9])
bst.debugAll ()

---

我试图在插入键时通过pdb进行调试，键被正确插入，但在遍历树时，某些节点被跳过，因为它们被标记为“非类型”。可能是我遗漏了一些语言细节

首先，下面的代码不正确：

        while (node.left != None and node.right != None):
            if node.key < key:
                node = node.right
            else:
                node = node.left

while（node.left！=无和node.right！=无）：
如果node.key

如果左侧或右侧节点不存在，它将停止下降

编辑：如果像这样修改循环，它会工作。可以更好地优化，但这只是一个开始

class Node():
    def __init__(self, parent=None, key=None):
        self.parent = parent if parent != None else None
        self.left = None
        self.right = None
        self.key = key if key != None else None

class BST():
    def __init__(self):
        self.root = Node()

    def insertKey (self, key):
        #pdb.set_trace()
        # transverse till we find empty position
        if (self.root.key == None):
            self.root.key = key
        else:
            node = self.root
            while 1:
                if node.key < key:
                    if node.right is None:
                        node.right = Node(node, key)
                        break
                    else:
                        node = node.right
                else:
                    if node.left is None:
                        node.left = Node(node, key)
                        break
                    else:
                        node = node.left

    def inOrder (self, node):
        #pdb.set_trace()
        if node != None:
            self.inOrder (node.left)
            print node.key
            self.inOrder (node.right)

    def printLeft (self, node):
        if node != None:
            self.printLeft (node)
            print node.key

    def debugAll (self):
        self.inOrder (self.root)
        #self.printLeft (self.root)

    def fromArray (self, numbers):
        srt = sorted(numbers)
        print srt
        length = len(srt)
        mid = length/2
        rootEle = srt[mid]
        self.insertKey (rootEle)
        for i in range (1, mid+1):
            try:
                #pdb.set_trace()
                self.insertKey (srt[mid-i])
                self.insertKey (srt[mid+i])
            except IndexError:
                pass

bst = BST()
bst.fromArray ([1,2,4,3,6,5,10,8,9])
bst.debugAll ()

class节点（）：
定义初始化（self，parent=None，key=None）：
self.parent=如果是父级，则为父级！=没有其他的没有
self.left=无
self.right=无
self.key=key如果是key！=没有其他的没有
类BST（）：
定义初始化（自）：
self.root=Node（）
def insertKey（自，钥匙）：
#pdb.set_trace（）
#直到我们找到空位
如果（self.root.key==无）：
self.root.key=key
其他：
node=self.root
而1：
如果node.key

您没有正确地形成树，因为它假设要找到一个节点，其中左节点或右节点都不存在，然后，我们将密钥放在新创建的节点中，相应地放在左节点或右节点中。但是如果您找到一个右节点不存在的节点，但您想在左节点中放置一些内容，发生了什么事？@user1064504——我更新了答案，它起作用了，至少在这种情况下是这样。立即想到两种可能的优化——第一种是不需要单独的树和节点类（每个节点都是树的起点），第二种是如果将左/右存储为具有两个值的单个子数组，则可以设置

index=node.key

，然后使用node.child[index]在循环中删掉一半的代码。玩得高兴另外，

self.parent=parent if parent！=除此之外，None

确实是惯用的，但如果您要存储None，则完全没有必要。只需使用

self.parent=None

。检查

是否为None

比检查

==None

更符合习惯（而且更便宜）。这之所以有效，是因为没有一个是单态的——只能有一个（无）。

class Node():
    def __init__(self, parent=None, key=None):
        self.parent = parent if parent != None else None
        self.left = None
        self.right = None
        self.key = key if key != None else None

class BST():
    def __init__(self):
        self.root = Node()

    def insertKey (self, key):
        #pdb.set_trace()
        # transverse till we find empty position
        if (self.root.key == None):
            self.root.key = key
        else:
            node = self.root
            while 1:
                if node.key < key:
                    if node.right is None:
                        node.right = Node(node, key)
                        break
                    else:
                        node = node.right
                else:
                    if node.left is None:
                        node.left = Node(node, key)
                        break
                    else:
                        node = node.left

    def inOrder (self, node):
        #pdb.set_trace()
        if node != None:
            self.inOrder (node.left)
            print node.key
            self.inOrder (node.right)

    def printLeft (self, node):
        if node != None:
            self.printLeft (node)
            print node.key

    def debugAll (self):
        self.inOrder (self.root)
        #self.printLeft (self.root)

    def fromArray (self, numbers):
        srt = sorted(numbers)
        print srt
        length = len(srt)
        mid = length/2
        rootEle = srt[mid]
        self.insertKey (rootEle)
        for i in range (1, mid+1):
            try:
                #pdb.set_trace()
                self.insertKey (srt[mid-i])
                self.insertKey (srt[mid+i])
            except IndexError:
                pass

bst = BST()
bst.fromArray ([1,2,4,3,6,5,10,8,9])
bst.debugAll ()