Question

我正在制作一个包含非常大的列表，几乎10000个对象的二叉树。问题是由于尺寸太大，我得到了最大的递归错误。它特别发生在被调用TreeNode来创建新对象的binarytree类中。我不确定如何在不递归的情况下实现这一点，因为这似乎是实现代码的最简单方法。

class TreeNode:
def __init__(self,key,val,left=None,right=None,parent=None):
    self.key = key
    self.payload = val
    self.leftChild = left
    self.rightChild = right
    self.parent = parent

def hasLeftChild(self):
    return self.leftChild

def hasRightChild(self):
    return self.rightChild

def isLeftChild(self):
    return self.parent and self.parent.leftChild == self

def isRightChild(self):
    return self.parent and self.parent.rightChild == self

def isRoot(self):
    return not self.parent

def isLeaf(self):
    return not (self.rightChild or self.leftChild)

def hasAnyChildren(self):
    return self.rightChild or self.leftChild

def hasBothChildren(self):
    return self.rightChild and self.leftChild

二叉树：

class BinarySearchTree:

def __init__(self):
    self.root = None
    self.size = 0

def length(self):
    return self.size

def __len__(self):
    return self.size

def put(self,key,val):
    if self.root:
        self._put(key,val,self.root)
    else:
        self.root = TreeNode(key,val)
    self.size = self.size + 1

def _put(self,key,val,currentNode):
    if key < currentNode.key:
        if currentNode.hasLeftChild():
               self._put(key,val,currentNode.leftChild)
        else:
               currentNode.leftChild = TreeNode(key,val,parent=currentNode)
    else:
        if currentNode.hasRightChild():
               self._put(key,val,currentNode.rightChild)
        else:
               currentNode.rightChild = TreeNode(key,val,parent=currentNode)

def __setitem__(self,k,v):
   self.put(k,v)

def get(self,key):
   if self.root:
       res = self._get(key,self.root)
       if res:
              return res.payload
       else:
              return None
   else:
       return None

def _get(self,key,currentNode):
   if not currentNode:
       return None
   elif currentNode.key == key:
       return currentNode
   elif key < currentNode.key:
       return self._get(key,currentNode.leftChild)
   else:
       return self._get(key,currentNode.rightChild)

def __getitem__(self,key):
   return self.get(key)

def __contains__(self,key):
   if self._get(key,self.root):
       return True
   else:
       return False

Answer 1

将递归方法转换为迭代方法非常简单，例如：

def get(self, key):
   node = self.root
   while node:
      if node.key == key:
         return node.payload
      elif key < node.key:
         node = node.leftChild
      else:
         node = node.rightChild
   return None

def put(self, key, val):
    if not self.root:
        self.root = TreeNode(key, val)
    else:
        self._put(key, val, self.root)
    self.size = self.size + 1

def _put(self, key, val, currentNode):
    while True:
        if key < currentNode.key:
            if currentNode.hasLeftChild():
                currentNode = currentNode.leftChild
            else:
                currentNode.leftChild = TreeNode(key, val, parent=currentNode)
                break
        else:
            if currentNode.hasRightChild():
                currentNode = currentNode.rightChild
            else:
                currentNode.rightChild = TreeNode(key, val, parent=currentNode)
                break

这消除了任何递归（限制），并且可读性强。

大列表的最大递归

1 个答案: