blocks|key|1067944|text|#+simple+binary+tree
#+in+this+implementation,+a+node+is+inserted+between+an+existing+node+and+the+root


class+BinaryTree():

++++def+__init__(self,rootid):
++++++self.left+=+None
++++++self.right+=+None
++++++self.rootid+=+rootid

++++def+getLeftChild(self):
++++++++return+self.left
++++def+getRightChild(self):
++++++++return+self.right
++++def+setNodeValue(self,value):
++++++++self.rootid+=+value
++++def+getNodeValue(self):
++++++++return+self.rootid

++++def+insertRight(self,newNode):
++++++++if+self.right+==+None:
++++++++++++self.right+=+BinaryTree(newNode)
++++++++else:
++++++++++++tree+=+BinaryTree(newNode)
++++++++++++tree.right+=+self.right
++++++++++++self.right+=+tree

++++def+insertLeft(self,newNode):
++++++++if+self.left+==+None:
++++++++++++self.left+=+BinaryTree(newNode)
++++++++else:
++++++++++++tree+=+BinaryTree(newNode)
++++++++++++tree.left+=+self.left
++++++++++++self.left+=+tree


def+printTree(tree):
++++++++if+tree+!=+None:
++++++++++++printTree(tree.getLeftChild())
++++++++++++print(tree.getNodeValue())
++++++++++++printTree(tree.getRightChild())



#+test+tree

def+testTree():
++++myTree+=+BinaryTree("Maud")
++++myTree.insertLeft("Bob")
++++myTree.insertRight("Tony")
++++myTree.insertRight("Steven")
++++printTree(myTree)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1067945|在这里阅读更多：-这是一个非常简单的二叉树implementation。|unstyled|offset|length|1067946|This是一个很好的教程，里面有问题|1067947|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pythonschool.net/data-structures-algorithms/binary-tree/|1|http://interactivepython.org/runestone/static/pythonds/Trees/SearchTreeImplementation.html^0|0|L|E|0|0|0|4|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@$G|W|H|X|1|Y]]|A|$]]|$1|I|3|J|5|F|7|Z|8|@]|9|@$G|10|H|11|1|12]]|A|$]]|$1|K|3|-4|5|F|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

<pre><code># simple binary tree
# in this implementation, a node is inserted between an existing node and the root


class BinaryTree():

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

 def getLeftChild(self):
 return self.left
 def getRightChild(self):
 return self.right
 def setNodeValue(self,value):
 self.rootid = value
 def getNodeValue(self):
 return self.rootid

 def insertRight(self,newNode):
 if self.right == None:
 self.right = BinaryTree(newNode)
 else:
 tree = BinaryTree(newNode)
 tree.right = self.right
 self.right = tree

 def insertLeft(self,newNode):
 if self.left == None:
 self.left = BinaryTree(newNode)
 else:
 tree = BinaryTree(newNode)
 tree.left = self.left
 self.left = tree


def printTree(tree):
 if tree != None:
 printTree(tree.getLeftChild())
 print(tree.getNodeValue())
 printTree(tree.getRightChild())



# test tree

def testTree():
 myTree = BinaryTree("Maud")
 myTree.insertLeft("Bob")
 myTree.insertRight("Tony")
 myTree.insertRight("Steven")
 printTree(myTree)
</code></pre>

Read more about it Here:-This is a very simple <a href="http://www.pythonschool.net/data-structures-algorithms/binary-tree/" rel="noreferrer">implementation</a> of a binary tree. 

<a href="http://interactivepython.org/runestone/static/pythonds/Trees/SearchTreeImplementation.html" rel="noreferrer">This</a> is a nice tutorial with questions in between

blocks|key|1067973|text|import+random

class+TreeNode:
++++def+__init__(self,+key):
++++++++self.key+=+key
++++++++self.left+=+None
++++++++self.right+=+None
++++++++self.p+=+None

class+BinaryTree:
++++def+__init__(self):
++++++++self.root+=+None

++++def+length(self):
++++++++return+self.size

++++def+inorder(self,+node):
++++++++if+node+==+None:
++++++++++++return+None
++++++++else:
++++++++++++self.inorder(node.left)
++++++++++++print+node.key,
++++++++++++self.inorder(node.right)

++++def+search(self,+k):
++++++++node+=+self.root
++++++++while+node+!=+None:
++++++++++++if+node.key+==+k:
++++++++++++++++return+node
++++++++++++if+node.key+>+k:
++++++++++++++++node+=+node.left
++++++++++++else:
++++++++++++++++node+=+node.right
++++++++return+None

++++def+minimum(self,+node):
++++++++x+=+None
++++++++while+node.left+!=+None:
++++++++++++x+=+node.left
++++++++++++node+=+node.left
++++++++return+x

++++def+maximum(self,+node):
++++++++x+=+None
++++++++while+node.right+!=+None:
++++++++++++x+=+node.right
++++++++++++node+=+node.right
++++++++return+x

++++def+successor(self,+node):
++++++++parent+=+None
++++++++if+node.right+!=+None:
++++++++++++return+self.minimum(node.right)
++++++++parent+=+node.p
++++++++while+parent+!=+None+and+node+==+parent.right:
++++++++++++node+=+parent
++++++++++++parent+=+parent.p
++++++++return+parent

++++def+predecessor(self,+node):
++++++++parent+=+None
++++++++if+node.left+!=+None:
++++++++++++return+self.maximum(node.left)
++++++++parent+=+node.p
++++++++while+parent+!=+None+and+node+==+parent.left:
++++++++++++node+=+parent
++++++++++++parent+=+parent.p
++++++++return+parent

++++def+insert(self,+k):
++++++++t+=+TreeNode(k)
++++++++parent+=+None
++++++++node+=+self.root
++++++++while+node+!=+None:
++++++++++++parent+=+node
++++++++++++if+node.key+>+t.key:
++++++++++++++++node+=+node.left
++++++++++++else:
++++++++++++++++node+=+node.right
++++++++t.p+=+parent
++++++++if+parent+==+None:
++++++++++++self.root+=+t
++++++++elif+t.key+<+parent.key:
++++++++++++parent.left+=+t
++++++++else:
++++++++++++parent.right+=+t
++++++++return+t


++++def+delete(self,+node):
++++++++if+node.left+==+None:
++++++++++++self.transplant(node,+node.right)
++++++++elif+node.right+==+None:
++++++++++++self.transplant(node,+node.left)
++++++++else:
++++++++++++succ+=+self.minimum(node.right)
++++++++++++if+succ.p+!=+node:
++++++++++++++++self.transplant(succ,+succ.right)
++++++++++++++++succ.right+=+node.right
++++++++++++++++succ.right.p+=+succ
++++++++++++self.transplant(node,+succ)
++++++++++++succ.left+=+node.left
++++++++++++succ.left.p+=+succ

++++def+transplant(self,+node,+newnode):
++++++++if+node.p+==+None:
++++++++++++self.root+=+newnode
++++++++elif+node+==+node.p.left:
++++++++++++node.p.left+=+newnode
++++++++else:
++++++++++++node.p.right+=+newnode
++++++++if+newnode+!=+None:
++++++++++++newnode.p+=+node.p|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1067974|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import random

class TreeNode:
 def __init__(self, key):
 self.key = key
 self.left = None
 self.right = None
 self.p = None

class BinaryTree:
 def __init__(self):
 self.root = None

 def length(self):
 return self.size

 def inorder(self, node):
 if node == None:
 return None
 else:
 self.inorder(node.left)
 print node.key,
 self.inorder(node.right)

 def search(self, k):
 node = self.root
 while node != None:
 if node.key == k:
 return node
 if node.key &gt; k:
 node = node.left
 else:
 node = node.right
 return None

 def minimum(self, node):
 x = None
 while node.left != None:
 x = node.left
 node = node.left
 return x

 def maximum(self, node):
 x = None
 while node.right != None:
 x = node.right
 node = node.right
 return x

 def successor(self, node):
 parent = None
 if node.right != None:
 return self.minimum(node.right)
 parent = node.p
 while parent != None and node == parent.right:
 node = parent
 parent = parent.p
 return parent

 def predecessor(self, node):
 parent = None
 if node.left != None:
 return self.maximum(node.left)
 parent = node.p
 while parent != None and node == parent.left:
 node = parent
 parent = parent.p
 return parent

 def insert(self, k):
 t = TreeNode(k)
 parent = None
 node = self.root
 while node != None:
 parent = node
 if node.key &gt; t.key:
 node = node.left
 else:
 node = node.right
 t.p = parent
 if parent == None:
 self.root = t
 elif t.key &lt; parent.key:
 parent.left = t
 else:
 parent.right = t
 return t


 def delete(self, node):
 if node.left == None:
 self.transplant(node, node.right)
 elif node.right == None:
 self.transplant(node, node.left)
 else:
 succ = self.minimum(node.right)
 if succ.p != node:
 self.transplant(succ, succ.right)
 succ.right = node.right
 succ.right.p = succ
 self.transplant(node, succ)
 succ.left = node.left
 succ.left.p = succ

 def transplant(self, node, newnode):
 if node.p == None:
 self.root = newnode
 elif node == node.p.left:
 node.p.left = newnode
 else:
 node.p.right = newnode
 if newnode != None:
 newnode.p = node.p
</code></pre>

blocks|key|1068038|text|使用列表实现二叉树的一种非常快速和肮脏的方法。不是最有效的方法，也不能很好地处理空值。但它非常透明(至少对我来说是这样)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068039|def+_add(node,+v):
++++new+=+[v,+[],+[]]
++++if+node:
++++++++left,+right+=+node[1:]
++++++++if+not+left:
++++++++++++left.extend(new)
++++++++elif+not+right:
++++++++++++right.extend(new)
++++++++else:
++++++++++++_add(left,+v)
++++else:
++++++++node.extend(new)

def+binary_tree(s):
++++root+=+[]
++++for+e+in+s:
++++++++_add(root,+e)
++++return+root

def+traverse(n,+order):
++++if+n:
++++++++v+=+n[0]
++++++++if+order+==+'pre':
++++++++++++yield+v
++++++++for+left+in+traverse(n[1],+order):
++++++++++++yield+left
++++++++if+order+==+'in':
++++++++++++yield+v
++++++++for+right+in+traverse(n[2],+order):
++++++++++++yield+right
++++++++if+order+==+'post':
++++++++++++yield+v|code-block|syntax|javascript|1068040|从一个迭代器构造一个树：|1068041|+>>>+tree+=+binary_tree('A+B+C+D+E'.split())
+>>>+print+tree
+['A',+['B',+['D',+[],+[]],+['E',+[],+[]]],+['C',+[],+[]]]|1068042|遍历树：|1068043|+>>>+list(traverse(tree,+'pre')),+list(traverse(tree,+'in')),+list(traverse(tree,+'post'))
+(['A',+'B',+'D',+'E',+'C'],
++['D',+'B',+'E',+'A',+'C'],
++['D',+'E',+'B',+'C',+'A'])|1068044|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A very quick 'n dirty way of implementing a binary tree using lists.
Not the most efficient, nor does it handle nil values all too well.
But it's very transparent (at least to me):

<pre class="lang-py prettyprint-override"><code>def _add(node, v):
 new = [v, [], []]
 if node:
 left, right = node[1:]
 if not left:
 left.extend(new)
 elif not right:
 right.extend(new)
 else:
 _add(left, v)
 else:
 node.extend(new)

def binary_tree(s):
 root = []
 for e in s:
 _add(root, e)
 return root

def traverse(n, order):
 if n:
 v = n[0]
 if order == 'pre':
 yield v
 for left in traverse(n[1], order):
 yield left
 if order == 'in':
 yield v
 for right in traverse(n[2], order):
 yield right
 if order == 'post':
 yield v
</code></pre>

Constructing a tree from an iterable:

<pre><code> &gt;&gt;&gt; tree = binary_tree('A B C D E'.split())
 &gt;&gt;&gt; print tree
 ['A', ['B', ['D', [], []], ['E', [], []]], ['C', [], []]]
</code></pre>

Traversing a tree:

<pre><code> &gt;&gt;&gt; list(traverse(tree, 'pre')), list(traverse(tree, 'in')), list(traverse(tree, 'post'))
 (['A', 'B', 'D', 'E', 'C'],
 ['D', 'B', 'E', 'A', 'C'],
 ['D', 'E', 'B', 'C', 'A'])
</code></pre>

blocks|key|1282805|text|下面是我的二进制搜索树的简单递归实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1282806|#!/usr/bin/python

class+Node:
++++def+__init__(self,+val):
++++++++self.l+=+None
++++++++self.r+=+None
++++++++self.v+=+val

class+Tree:
++++def+__init__(self):
++++++++self.root+=+None

++++def+getRoot(self):
++++++++return+self.root

++++def+add(self,+val):
++++++++if+self.root+is+None:
++++++++++++self.root+=+Node(val)
++++++++else:
++++++++++++self._add(val,+self.root)

++++def+_add(self,+val,+node):
++++++++if+val+<+node.v:
++++++++++++if+node.l+is+not+None:
++++++++++++++++self._add(val,+node.l)
++++++++++++else:
++++++++++++++++node.l+=+Node(val)
++++++++else:
++++++++++++if+node.r+is+not+None:
++++++++++++++++self._add(val,+node.r)
++++++++++++else:
++++++++++++++++node.r+=+Node(val)

++++def+find(self,+val):
++++++++if+self.root+is+not+None:
++++++++++++return+self._find(val,+self.root)
++++++++else:
++++++++++++return+None

++++def+_find(self,+val,+node):
++++++++if+val+==+node.v:
++++++++++++return+node
++++++++elif+(val+<+node.v+and+node.l+is+not+None):
++++++++++++return+self._find(val,+node.l)
++++++++elif+(val+>+node.v+and+node.r+is+not+None):
++++++++++++return+self._find(val,+node.r)

++++def+deleteTree(self):
++++++++#+garbage+collector+will+do+this+for+us.+
++++++++self.root+=+None

++++def+printTree(self):
++++++++if+self.root+is+not+None:
++++++++++++self._printTree(self.root)

++++def+_printTree(self,+node):
++++++++if+node+is+not+None:
++++++++++++self._printTree(node.l)
++++++++++++print(str(node.v)+%2B+'+')
++++++++++++self._printTree(node.r)

#+++++3
#+0+++++4
#+++2++++++8
tree+=+Tree()
tree.add(3)
tree.add(4)
tree.add(0)
tree.add(8)
tree.add(2)
tree.printTree()
print(tree.find(3).v)
print(tree.find(10))
tree.deleteTree()
tree.printTree()|code-block|syntax|javascript|1282807|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my simple recursive implementation of binary search tree.
<pre><code>#!/usr/bin/python

class Node:
 def __init__(self, val):
 self.l = None
 self.r = None
 self.v = val

class Tree:
 def __init__(self):
 self.root = None

 def getRoot(self):
 return self.root

 def add(self, val):
 if self.root is None:
 self.root = Node(val)
 else:
 self._add(val, self.root)

 def _add(self, val, node):
 if val &lt; node.v:
 if node.l is not None:
 self._add(val, node.l)
 else:
 node.l = Node(val)
 else:
 if node.r is not None:
 self._add(val, node.r)
 else:
 node.r = Node(val)

 def find(self, val):
 if self.root is not None:
 return self._find(val, self.root)
 else:
 return None

 def _find(self, val, node):
 if val == node.v:
 return node
 elif (val &lt; node.v and node.l is not None):
 return self._find(val, node.l)
 elif (val &gt; node.v and node.r is not None):
 return self._find(val, node.r)

 def deleteTree(self):
 # garbage collector will do this for us. 
 self.root = None

 def printTree(self):
 if self.root is not None:
 self._printTree(self.root)

 def _printTree(self, node):
 if node is not None:
 self._printTree(node.l)
 print(str(node.v) + ' ')
 self._printTree(node.r)

# 3
# 0 4
# 2 8
tree = Tree()
tree.add(3)
tree.add(4)
tree.add(0)
tree.add(8)
tree.add(2)
tree.printTree()
print(tree.find(3).v)
print(tree.find(10))
tree.deleteTree()
tree.printTree()
</code></pre>

blocks|key|1282866|text|您不需要有两个类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1282867|class+Tree:
++++val+=+None
++++left+=+None
++++right+=+None

++++def+__init__(self,+val):
++++++++self.val+=+val


++++def+insert(self,+val):
++++++++if+self.val+is+not+None:
++++++++++++if+val+<+self.val:
++++++++++++++++if+self.left+is+not+None:
++++++++++++++++++++self.left.insert(val)
++++++++++++++++else:
++++++++++++++++++++self.left+=+Tree(val)
++++++++++++elif+val+>+self.val:
++++++++++++++++if+self.right+is+not+None:
++++++++++++++++++++self.right.insert(val)
++++++++++++++++else:
++++++++++++++++++++self.right+=+Tree(val)
++++++++++++else:
++++++++++++++++return
++++++++else:
++++++++++++self.val+=+val
++++++++++++print("new+node+added")

++++def+showTree(self):
++++++++if+self.left+is+not+None:
++++++++++++self.left.showTree()
++++++++print(self.val,+end+=+'+')
++++++++if+self.right+is+not+None:
++++++++++++self.right.showTree()|code-block|syntax|javascript|1282868|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

you don't need to have two classes

<pre><code>class Tree:
 val = None
 left = None
 right = None

 def __init__(self, val):
 self.val = val


 def insert(self, val):
 if self.val is not None:
 if val &lt; self.val:
 if self.left is not None:
 self.left.insert(val)
 else:
 self.left = Tree(val)
 elif val &gt; self.val:
 if self.right is not None:
 self.right.insert(val)
 else:
 self.right = Tree(val)
 else:
 return
 else:
 self.val = val
 print("new node added")

 def showTree(self):
 if self.left is not None:
 self.left.showTree()
 print(self.val, end = ' ')
 if self.right is not None:
 self.right.showTree()
</code></pre>

blocks|key|1282909|text|BST在Python中的简单实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1282910|class+TreeNode:
++++def+__init__(self,+value):
++++++++self.left+=+None
++++++++self.right+=+None
++++++++self.data+=+value

class+Tree:
++++def+__init__(self):
++++++++self.root+=+None

++++def+addNode(self,+node,+value):
++++++++if(node==None):
++++++++++++self.root+=+TreeNode(value)
++++++++else:
++++++++++++if(value<node.data):
++++++++++++++++if(node.left==None):
++++++++++++++++++++node.left+=+TreeNode(value)
++++++++++++++++else:
++++++++++++++++++++self.addNode(node.left,+value)
++++++++++++else:
++++++++++++++++if(node.right==None):
++++++++++++++++++++node.right+=+TreeNode(value)
++++++++++++++++else:
++++++++++++++++++++self.addNode(node.right,+value)

++++def+printInorder(self,+node):
++++++++if(node!=None):
++++++++++++self.printInorder(node.left)
++++++++++++print(node.data)
++++++++++++self.printInorder(node.right)

def+main():
++++testTree+=+Tree()
++++testTree.addNode(testTree.root,+200)
++++testTree.addNode(testTree.root,+300)
++++testTree.addNode(testTree.root,+100)
++++testTree.addNode(testTree.root,+30)
++++testTree.printInorder(testTree.root)|code-block|syntax|javascript|1282911|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple implementation of BST in Python 

<pre><code>class TreeNode:
 def __init__(self, value):
 self.left = None
 self.right = None
 self.data = value

class Tree:
 def __init__(self):
 self.root = None

 def addNode(self, node, value):
 if(node==None):
 self.root = TreeNode(value)
 else:
 if(value&lt;node.data):
 if(node.left==None):
 node.left = TreeNode(value)
 else:
 self.addNode(node.left, value)
 else:
 if(node.right==None):
 node.right = TreeNode(value)
 else:
 self.addNode(node.right, value)

 def printInorder(self, node):
 if(node!=None):
 self.printInorder(node.left)
 print(node.data)
 self.printInorder(node.right)

def main():
 testTree = Tree()
 testTree.addNode(testTree.root, 200)
 testTree.addNode(testTree.root, 300)
 testTree.addNode(testTree.root, 100)
 testTree.addNode(testTree.root, 30)
 testTree.printInorder(testTree.root)
</code></pre>

blocks|key|1282942|text|Python中的二叉树|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1282943|+class+Tree(object):
++++def+__init__(self):
++++++++self.data=None
++++++++self.left=None
++++++++self.right=None
++++def+insert(self,+x,+root):
++++++++if+root==None:
++++++++++++t=node(x)
++++++++++++t.data=x
++++++++++++t.right=None
++++++++++++t.left=None
++++++++++++root=t
++++++++++++return+root
++++++++elif+x<root.data:
++++++++++++root.left=self.insert(x,+root.left)
++++++++else:
++++++++++++root.right=self.insert(x,+root.right)
++++++++return+root

++++def+printTree(self,+t):
++++++++if+t==None:
++++++++++++return

++++++++self.printTree(t.left)
++++++++print+t.data
++++++++self.printTree(t.right)

class+node(object):
++++def+__init__(self,+x):
++++++++self.x=x

bt=Tree()
root=None
n=int(raw_input())
a=[]
for+i+in+range(n):
++++a.append(int(raw_input()))
for+i+in+range(n):
++++root=bt.insert(a[i],+root)
bt.printTree(root)|code-block|syntax|javascript|1282944|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Binary Tree in Python

<pre><code> class Tree(object):
 def __init__(self):
 self.data=None
 self.left=None
 self.right=None
 def insert(self, x, root):
 if root==None:
 t=node(x)
 t.data=x
 t.right=None
 t.left=None
 root=t
 return root
 elif x&lt;root.data:
 root.left=self.insert(x, root.left)
 else:
 root.right=self.insert(x, root.right)
 return root

 def printTree(self, t):
 if t==None:
 return

 self.printTree(t.left)
 print t.data
 self.printTree(t.right)

class node(object):
 def __init__(self, x):
 self.x=x

bt=Tree()
root=None
n=int(raw_input())
a=[]
for i in range(n):
 a.append(int(raw_input()))
for i in range(n):
 root=bt.insert(a[i], root)
bt.printTree(root)
</code></pre>

blocks|key|1068287|text|有点"Pythonic“？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068288|class+Node:
++++def+__init__(self,+value):
++++++++self.value+=+value
++++++++self.left+=+None
++++++++self.right+=+None

++++def+__repr__(self):
++++++++return+str(self.value)



class+BST:
++++def+__init__(self):
++++++++self.root+=+None

++++def+__repr__(self):
++++++++self.sorted+=+[]
++++++++self.get_inorder(self.root)
++++++++return+str(self.sorted)

++++def+get_inorder(self,+node):
++++++++if+node:
++++++++++++self.get_inorder(node.left)
++++++++++++self.sorted.append(str(node.value))
++++++++++++self.get_inorder(node.right)

++++def+add(self,+value):
++++++++if+not+self.root:
++++++++++++self.root+=+Node(value)
++++++++else:
++++++++++++self._add(self.root,+value)

++++def+_add(self,+node,+value):
++++++++if+value+<=+node.value:
++++++++++++if+node.left:
++++++++++++++++self._add(node.left,+value)
++++++++++++else:
++++++++++++++++node.left+=+Node(value)
++++++++else:
++++++++++++if+node.right:
++++++++++++++++self._add(node.right,+value)
++++++++++++else:
++++++++++++++++node.right+=+Node(value)



from+random+import+randint

bst+=+BST()

for+i+in+range(100):
++++bst.add(randint(1,+1000))
print+(bst)|code-block|syntax|javascript|1068289|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A little more "Pythonic" ?

<pre><code>class Node:
 def __init__(self, value):
 self.value = value
 self.left = None
 self.right = None

 def __repr__(self):
 return str(self.value)



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

 def __repr__(self):
 self.sorted = []
 self.get_inorder(self.root)
 return str(self.sorted)

 def get_inorder(self, node):
 if node:
 self.get_inorder(node.left)
 self.sorted.append(str(node.value))
 self.get_inorder(node.right)

 def add(self, value):
 if not self.root:
 self.root = Node(value)
 else:
 self._add(self.root, value)

 def _add(self, node, value):
 if value &lt;= node.value:
 if node.left:
 self._add(node.left, value)
 else:
 node.left = Node(value)
 else:
 if node.right:
 self._add(node.right, value)
 else:
 node.right = Node(value)



from random import randint

bst = BST()

for i in range(100):
 bst.add(randint(1, 1000))
print (bst)
</code></pre>

blocks|key|1068293|text|#!/usr/bin/python

class+BinaryTree:
++++def+__init__(self,+left,+right,+data):
++++++++self.left+=+left
++++++++self.right+=+right
++++++++self.data+=+data


++++def+pre_order_traversal(root):
++++++++print(root.data,+end='+')

++++++++if+root.left+!=+None:
++++++++++++pre_order_traversal(root.left)

++++++++if+root.right+!=+None:
++++++++++++pre_order_traversal(root.right)

++++def+in_order_traversal(root):
++++++++if+root.left+!=+None:
++++++++++++in_order_traversal(root.left)
++++++++print(root.data,+end='+')
++++++++if+root.right+!=+None:
++++++++++++in_order_traversal(root.right)

++++def+post_order_traversal(root):
++++++++if+root.left+!=+None:
++++++++++++post_order_traversal(root.left)
++++++++if+root.right+!=+None:
++++++++++++post_order_traversal(root.right)
++++++++print(root.data,+end='+')|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1068294|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#!/usr/bin/python

class BinaryTree:
 def __init__(self, left, right, data):
 self.left = left
 self.right = right
 self.data = data


 def pre_order_traversal(root):
 print(root.data, end=' ')

 if root.left != None:
 pre_order_traversal(root.left)

 if root.right != None:
 pre_order_traversal(root.right)

 def in_order_traversal(root):
 if root.left != None:
 in_order_traversal(root.left)
 print(root.data, end=' ')
 if root.right != None:
 in_order_traversal(root.right)

 def post_order_traversal(root):
 if root.left != None:
 post_order_traversal(root.left)
 if root.right != None:
 post_order_traversal(root.right)
 print(root.data, end=' ')
</code></pre>

blocks|key|1283030|text|此实现支持插入、查找和删除操作，而不会破坏树的结构。这不是一棵平衡树。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283031|#+Class+for+construct+the+nodes+of+the+tree.+(Subtrees)
class+Node:
def+__init__(self,+key,+parent_node+=+None):
++++self.left+=+None
++++self.right+=+None
++++self.key+=+key
++++if+parent_node+==+None:
++++++++self.parent+=+self
++++else:
++++++++self.parent+=+parent_node

#+Class+with+the++structure+of+the+tree.+
#+This+Tree+is+not+balanced.
class+Tree:
def+__init__(self):
++++self.root+=+None

#+Insert+a+single+element
def+insert(self,+x):
++++if(self.root+==+None):
++++++++self.root+=+Node(x)
++++else:
++++++++self._insert(x,+self.root)

def+_insert(self,+x,+node):
++++if(x+<+node.key):
++++++++if(node.left+==+None):
++++++++++++node.left+=+Node(x,+node)
++++++++else:
++++++++++++self._insert(x,+node.left)
++++else:
++++++++if(node.right+==+None):
++++++++++++node.right+=+Node(x,+node)
++++++++else:
++++++++++++self._insert(x,+node.right)

#+Given+a+element,+return+a+node+in+the+tree+with+key+x.+
def+find(self,+x):
++++if(self.root+==+None):
++++++++return+None
++++else:
++++++++return+self._find(x,+self.root)
def+_find(self,+x,+node):
++++if(x+==+node.key):
++++++++return+node
++++elif(x+<+node.key):
++++++++if(node.left+==+None):
++++++++++++return+None
++++++++else:
++++++++++++return+self._find(x,+node.left)
++++elif(x+>+node.key):
++++++++if(node.right+==+None):
++++++++++++return+None
++++++++else:
++++++++++++return+self._find(x,+node.right)

#+Given+a+node,+return+the+node+in+the+tree+with+the+next+largest+element.
def+next(self,+node):
++++if+node.right+!=+None:
++++++++return+self._left_descendant(node.right)
++++else:
++++++++return+self._right_ancestor(node)

def+_left_descendant(self,+node):
++++if+node.left+==+None:
++++++++return+node
++++else:
++++++++return+self._left_descendant(node.left)

def+_right_ancestor(self,+node):
++++if+node.key+<=+node.parent.key:
++++++++return+node.parent
++++else:
++++++++return+self._right_ancestor(node.parent)

#+Delete+an+element+of+the+tree
def+delete(self,+x):
++++node+=+self.find(x)
++++if+node+==+None:
++++++++print(x,+"isn't+in+the+tree")
++++else:
++++++++if+node.right+==+None:
++++++++++++if+node.left+==+None:
++++++++++++++++if+node.key+<+node.parent.key:
++++++++++++++++++++node.parent.left+=+None
++++++++++++++++++++del+node+#+Clean+garbage
++++++++++++++++else:
++++++++++++++++++++node.parent.right+=+None
++++++++++++++++++++del+Node+#+Clean+garbage
++++++++++++else:
++++++++++++++++node.key+=+node.left.key
++++++++++++++++node.left+=+None
++++++++else:
++++++++++++x+=+self.next(node)
++++++++++++node.key+=+x.key
++++++++++++x+=+None


#+tests
t+=+Tree()
t.insert(5)
t.insert(8)
t.insert(3)
t.insert(4)
t.insert(6)
t.insert(2)

t.delete(8)
t.delete(5)

t.insert(9)
t.insert(1)

t.delete(2)
t.delete(100)

#+Remember:+Find+method+return+the+node+object.+
#+To+return+a+number+use+t.find(nº).key
#+But+it+will+cause+an+error+if+the+number+is+not+in+the+tree.
print(t.find(5))+
print(t.find(8))
print(t.find(4))
print(t.find(6))
print(t.find(9))|code-block|syntax|javascript|1283032|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This implementation supports insert, find and delete operations without destroy the structure of the tree. This is not a banlanced tree.

<pre><code># Class for construct the nodes of the tree. (Subtrees)
class Node:
def __init__(self, key, parent_node = None):
 self.left = None
 self.right = None
 self.key = key
 if parent_node == None:
 self.parent = self
 else:
 self.parent = parent_node

# Class with the structure of the tree. 
# This Tree is not balanced.
class Tree:
def __init__(self):
 self.root = None

# Insert a single element
def insert(self, x):
 if(self.root == None):
 self.root = Node(x)
 else:
 self._insert(x, self.root)

def _insert(self, x, node):
 if(x &lt; node.key):
 if(node.left == None):
 node.left = Node(x, node)
 else:
 self._insert(x, node.left)
 else:
 if(node.right == None):
 node.right = Node(x, node)
 else:
 self._insert(x, node.right)

# Given a element, return a node in the tree with key x. 
def find(self, x):
 if(self.root == None):
 return None
 else:
 return self._find(x, self.root)
def _find(self, x, node):
 if(x == node.key):
 return node
 elif(x &lt; node.key):
 if(node.left == None):
 return None
 else:
 return self._find(x, node.left)
 elif(x &gt; node.key):
 if(node.right == None):
 return None
 else:
 return self._find(x, node.right)

# Given a node, return the node in the tree with the next largest element.
def next(self, node):
 if node.right != None:
 return self._left_descendant(node.right)
 else:
 return self._right_ancestor(node)

def _left_descendant(self, node):
 if node.left == None:
 return node
 else:
 return self._left_descendant(node.left)

def _right_ancestor(self, node):
 if node.key &lt;= node.parent.key:
 return node.parent
 else:
 return self._right_ancestor(node.parent)

# Delete an element of the tree
def delete(self, x):
 node = self.find(x)
 if node == None:
 print(x, "isn't in the tree")
 else:
 if node.right == None:
 if node.left == None:
 if node.key &lt; node.parent.key:
 node.parent.left = None
 del node # Clean garbage
 else:
 node.parent.right = None
 del Node # Clean garbage
 else:
 node.key = node.left.key
 node.left = None
 else:
 x = self.next(node)
 node.key = x.key
 x = None


# tests
t = Tree()
t.insert(5)
t.insert(8)
t.insert(3)
t.insert(4)
t.insert(6)
t.insert(2)

t.delete(8)
t.delete(5)

t.insert(9)
t.insert(1)

t.delete(2)
t.delete(100)

# Remember: Find method return the node object. 
# To return a number use t.find(nº).key
# But it will cause an error if the number is not in the tree.
print(t.find(5)) 
print(t.find(8))
print(t.find(4))
print(t.find(6))
print(t.find(9))
</code></pre>

blocks|key|1068399|text|这是一个简单的解决方案，可以使用递归方法来构建二叉树，以便在下面的代码中使用顺序遍历来显示树。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068400|class+Node(object):

++++def+__init__(self):
++++++++self.left+=+None
++++++++self.right+=+None
++++++++self.value+=+None
++++@property
++++def+get_value(self):
++++++++return+self.value

++++@property
++++def+get_left(self):
++++++++return+self.left

++++@property
++++def+get_right(self):
++++++++return+self.right

++++@get_left.setter
++++def+set_left(self,+left_node):
++++++++self.left+=+left_node
++++@get_value.setter
++++def+set_value(self,+value):
++++++++self.value+=+value
++++@get_right.setter
++++def+set_right(self,+right_node):
++++++++self.right+=+right_node



++++def+create_tree(self):
++++++++_node+=+Node()+#creating+new+node.
++++++++_x+=+input("Enter+the+node+data(-1+for+null)")
++++++++if(_x+==+str(-1)):+#for+defining+no+child.
++++++++++++return+None
++++++++_node.set_value+=+_x+#setting+the+value+of+the+node.
++++++++print("Enter+the+left+child+of+{}".format(_x))
++++++++_node.set_left+=+self.create_tree()+#setting+the+left+subtree
++++++++print("Enter+the+right+child+of+{}".format(_x))
++++++++_node.set_right+=+self.create_tree()+#setting+the+right+subtree.

++++++++return+_node

++++def+pre_order(self,+root):
++++++++if+root+is+not+None:
++++++++++++print(root.get_value)
++++++++++++self.pre_order(root.get_left)
++++++++++++self.pre_order(root.get_right)

if+__name__+==+'__main__':
++++node+=+Node()
++++root_node+=+node.create_tree()
++++node.pre_order(root_node)|code-block|syntax|javascript|1068401|代码摘自：Binary+Tree+in+Python|offset|length|1068402|entityMap|0|LINK|mutability|MUTABLE|url|http://www.psychocodes.in/binary-tree-in-python.html^0|0|0|5|L|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Here is a simple solution which can be used to build a binary tree using a recursive approach to display the tree in order traversal has been used in the below code.

<pre><code>class Node(object):

 def __init__(self):
 self.left = None
 self.right = None
 self.value = None
 @property
 def get_value(self):
 return self.value

 @property
 def get_left(self):
 return self.left

 @property
 def get_right(self):
 return self.right

 @get_left.setter
 def set_left(self, left_node):
 self.left = left_node
 @get_value.setter
 def set_value(self, value):
 self.value = value
 @get_right.setter
 def set_right(self, right_node):
 self.right = right_node



 def create_tree(self):
 _node = Node() #creating new node.
 _x = input("Enter the node data(-1 for null)")
 if(_x == str(-1)): #for defining no child.
 return None
 _node.set_value = _x #setting the value of the node.
 print("Enter the left child of {}".format(_x))
 _node.set_left = self.create_tree() #setting the left subtree
 print("Enter the right child of {}".format(_x))
 _node.set_right = self.create_tree() #setting the right subtree.

 return _node

 def pre_order(self, root):
 if root is not None:
 print(root.get_value)
 self.pre_order(root.get_left)
 self.pre_order(root.get_right)

if __name__ == '__main__':
 node = Node()
 root_node = node.create_tree()
 node.pre_order(root_node)
</code></pre>

Code taken from : <a href="http://www.psychocodes.in/binary-tree-in-python.html" rel="nofollow noreferrer">Binary Tree in Python</a>

blocks|key|1283167|text|面试Node类需要的是足够的数据结构来表示二叉树。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283168|(虽然其他答案大部分是正确的，但它们不是二叉树所必需的:不需要扩展对象类，不需要是BST，不需要导入deque)。|1283169|class+Node:

++++def+__init__(self,+value+=+None):
++++++++self.left++=+None
++++++++self.right+=+None
++++++++self.value+=+value|code-block|syntax|javascript|1283170|下面是一个树的示例：|1283171|n1+=+Node(1)
n2+=+Node(2)
n3+=+Node(3)
n1.left++=+n2
n1.right+=+n3|1283172|在本例中，n1是以n2和n3作为其子级的树的根。|1283173|​|1283174|📷|atomic|offset|length|1283175|1283176|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/ba0cccf1a21a11a3cf6478492831eeed.png|imageAlt^0|0|0|0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|18|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1C|8|@]|9|@$T|1D|U|1E|1|1F]]|A|$]]|$1|V|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13|14|-4]]]]

[What you need for interviews] A Node class is the sufficient data structure to represent a binary tree. 

(While other answers are mostly correct, they are not required for a binary tree: no need to extend object class, no need to be a BST, no need to import deque). 

<pre><code>class Node:

 def __init__(self, value = None):
 self.left = None
 self.right = None
 self.value = value
</code></pre>

Here is an example of a tree: 

<pre><code>n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n1.left = n2
n1.right = n3
</code></pre>

In this example n1 is the root of the tree having n2, n3 as its children.

<a href="https://i.stack.imgur.com/Ht58m.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Ht58m.png" alt="enter image description here"></a>

blocks|key|1068626|text|我知道已经发布了许多好的解决方案，但我通常对二叉树有一个不同的方法:使用一些Node类并直接实现它更具可读性，但是当你有很多节点时，它可能会变得非常贪婪，关于内存，所以我建议增加一层复杂性并将节点存储在python列表中，然后只使用列表来模拟树的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068627|您仍然可以定义一个Node类，以便在需要时最终表示树中的节点，但是将它们保存在一个简单的形式值中，列表中的left、right将占用一半或更少的内存！|1068628|下面是一个在数组中存储节点的Binary+Search+Tree类的快速示例。它提供了基本的功能，如添加，删除，查找...|1068629|"""
Basic+Binary+Search+Tree+class+without+recursion...
"""

__author__+=+"@fbparis"

class+Node(object):
++++__slots__+=+"value",+"parent",+"left",+"right"
++++def+__init__(self,+value,+parent=None,+left=None,+right=None):
++++++++self.value+=+value
++++++++self.parent+=+parent
++++++++self.left+=+left
++++++++self.right+=+right

++++def+__repr__(self):
++++++++return+"<%25s+object+at+%25s:+parent=%25s,+left=%25s,+right=%25s,+value=%25s>"+%25+(self.__class__.__name__,+hex(id(self)),+self.parent,+self.left,+self.right,+self.value)

class+BinarySearchTree(object):
++++__slots__+=+"_tree"
++++def+__init__(self,+*args):
++++++++self._tree+=+[]
++++++++if+args:
++++++++++++for+x+in+args[0]:
++++++++++++++++self.add(x)

++++def+__len__(self):
++++++++return+len(self._tree)

++++def+__repr__(self):
++++++++return+"<%25s+object+at+%25s+with+%25d+nodes>"+%25+(self.__class__.__name__,+hex(id(self)),+len(self))

++++def+__str__(self,+nodes=None,+level=0):
++++++++ret+=+""
++++++++if+nodes+is+None:
++++++++++++if+len(self):
++++++++++++++++nodes+=+[0]
++++++++++++else:
++++++++++++++++nodes+=+[]
++++++++for+node+in+nodes:
++++++++++++if+node+is+None:
++++++++++++++++continue
++++++++++++ret+%2B=+"-"+*+level+%2B+"+%25s\n"+%25+self._tree[node][0]
++++++++++++ret+%2B=+self.__str__(self._tree[node][2:4],+level+%2B+1)
++++++++if+level+==+0:
++++++++++++ret+=+ret.strip()
++++++++return+ret

++++def+__contains__(self,+value):
++++++++if+len(self):
++++++++++++node_index+=+0
++++++++++++while+self._tree[node_index][0]+!=+value:
++++++++++++++++if+value+<+self._tree[node_index][0]:
++++++++++++++++++++node_index+=+self._tree[node_index][2]
++++++++++++++++else:
++++++++++++++++++++node_index+=+self._tree[node_index][3]
++++++++++++++++if+node_index+is+None:
++++++++++++++++++++return+False
++++++++++++return+True
++++++++return+False

++++def+__eq__(self,+other):
++++++++return+self._tree+==+other._tree

++++def+add(self,+value):
++++++++if+len(self):
++++++++++++node_index+=+0
++++++++++++while+self._tree[node_index][0]+!=+value:
++++++++++++++++if+value+<+self._tree[node_index][0]:
++++++++++++++++++++b+=+self._tree[node_index][2]
++++++++++++++++++++k+=+2
++++++++++++++++else:
++++++++++++++++++++b+=+self._tree[node_index][3]
++++++++++++++++++++k+=+3
++++++++++++++++if+b+is+None:
++++++++++++++++++++self._tree[node_index][k]+=+len(self)
++++++++++++++++++++self._tree.append([value,+node_index,+None,+None])
++++++++++++++++++++break
++++++++++++++++node_index+=+b
++++++++else:
++++++++++++self._tree.append([value,+None,+None,+None])

++++def+remove(self,+value):
++++++++if+len(self):
++++++++++++node_index+=+0
++++++++++++while+self._tree[node_index][0]+!=+value:
++++++++++++++++if+value+<+self._tree[node_index][0]:
++++++++++++++++++++node_index+=+self._tree[node_index][2]
++++++++++++++++else:
++++++++++++++++++++node_index+=+self._tree[node_index][3]
++++++++++++++++if+node_index+is+None:
++++++++++++++++++++raise+KeyError
++++++++++++if+self._tree[node_index][2]+is+not+None:
++++++++++++++++b,+d+=+2,+3
++++++++++++elif+self._tree[node_index][3]+is+not+None:
++++++++++++++++b,+d+=+3,+2
++++++++++++else:
++++++++++++++++i+=+node_index
++++++++++++++++b+=+None
++++++++++++if+b+is+not+None:
++++++++++++++++i+=+self._tree[node_index][b]
++++++++++++++++while+self._tree[i][d]+is+not+None:
++++++++++++++++++++i+=+self._tree[i][d]
++++++++++++++++p+=+self._tree[i][1]
++++++++++++++++b+=+self._tree[i][b]
++++++++++++++++if+p+==+node_index:
++++++++++++++++++++self._tree[p][5-d]+=+b
++++++++++++++++else:
++++++++++++++++++++self._tree[p][d]+=+b
++++++++++++++++if+b+is+not+None:
++++++++++++++++++++self._tree[b][1]+=+p
++++++++++++++++self._tree[node_index][0]+=+self._tree[i][0]
++++++++++++else:
++++++++++++++++p+=+self._tree[i][1]
++++++++++++++++if+p+is+not+None:
++++++++++++++++++++if+self._tree[p][2]+==+i:
++++++++++++++++++++++++self._tree[p][2]+=+None
++++++++++++++++++++else:
++++++++++++++++++++++++self._tree[p][3]+=+None
++++++++++++last+=+self._tree.pop()
++++++++++++n+=+len(self)
++++++++++++if+i+<+n:
++++++++++++++++self._tree[i]+=+last[:]
++++++++++++++++if+last[2]+is+not+None:
++++++++++++++++++++self._tree[last[2]][1]+=+i
++++++++++++++++if+last[3]+is+not+None:
++++++++++++++++++++self._tree[last[3]][1]+=+i
++++++++++++++++if+self._tree[last[1]][2]+==+n:
++++++++++++++++++++self._tree[last[1]][2]+=+i
++++++++++++++++else:
++++++++++++++++++++self._tree[last[1]][3]+=+i
++++++++else:
++++++++++++raise+KeyError

++++def+find(self,+value):
++++++++if+len(self):
++++++++++++node_index+=+0
++++++++++++while+self._tree[node_index][0]+!=+value:
++++++++++++++++if+value+<+self._tree[node_index][0]:
++++++++++++++++++++node_index+=+self._tree[node_index][2]
++++++++++++++++else:
++++++++++++++++++++node_index+=+self._tree[node_index][3]
++++++++++++++++if+node_index+is+None:
++++++++++++++++++++return+None
++++++++++++return+Node(*self._tree[node_index])
++++++++return+None|code-block|syntax|javascript|1068630|我已经添加了一个父属性，这样您就可以删除任何节点并维护BST结构。|1068631|对于可读性，特别是对于"remove“函数，我很抱歉。基本上，当一个节点被删除时，我们弹出树数组，并用最后一个元素替换它(除非我们想要删除最后一个节点)。为了维护BST结构，删除的节点被替换为其左子节点的最大值或右子节点的最小值，并且必须执行一些操作以保持索引有效，但这已经足够快了。|1068632|我将这种技术用于更高级的东西，构建了一些带有内部基数trie的大单词字典，并且我能够将内存消耗除以7-8+(您可以在这里看到一个示例：https://gist.github.com/fbparis/b3ddd5673b603b42c880974b23db7cda)。|offset|length|1068633|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/fbparis/b3ddd5673b603b42c880974b23db7cda^0|0|0|0|0|0|0|1V|1S|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I know many good solutions have already been posted but I usually have a different approach for binary trees: going with some Node class and implementing it directly is more readable but when you have a lot of nodes it can become very greedy regarding memory, so I suggest adding one layer of complexity and storing the nodes in a python list, and then simulating a tree behavior using only the list.

You can still define a Node class to finally represent the nodes in the tree when needed, but keeping them in a simple form [value, left, right] in a list will use half the memory or less!

Here is a quick example of a Binary Search Tree class storing the nodes in an array. It provides basic fonctions such as add, remove, find...

<pre><code>"""
Basic Binary Search Tree class without recursion...
"""

__author__ = "@fbparis"

class Node(object):
 __slots__ = "value", "parent", "left", "right"
 def __init__(self, value, parent=None, left=None, right=None):
 self.value = value
 self.parent = parent
 self.left = left
 self.right = right

 def __repr__(self):
 return "&lt;%s object at %s: parent=%s, left=%s, right=%s, value=%s&gt;" % (self.__class__.__name__, hex(id(self)), self.parent, self.left, self.right, self.value)

class BinarySearchTree(object):
 __slots__ = "_tree"
 def __init__(self, *args):
 self._tree = []
 if args:
 for x in args[0]:
 self.add(x)

 def __len__(self):
 return len(self._tree)

 def __repr__(self):
 return "&lt;%s object at %s with %d nodes&gt;" % (self.__class__.__name__, hex(id(self)), len(self))

 def __str__(self, nodes=None, level=0):
 ret = ""
 if nodes is None:
 if len(self):
 nodes = [0]
 else:
 nodes = []
 for node in nodes:
 if node is None:
 continue
 ret += "-" * level + " %s\n" % self._tree[node][0]
 ret += self.__str__(self._tree[node][2:4], level + 1)
 if level == 0:
 ret = ret.strip()
 return ret

 def __contains__(self, value):
 if len(self):
 node_index = 0
 while self._tree[node_index][0] != value:
 if value &lt; self._tree[node_index][0]:
 node_index = self._tree[node_index][2]
 else:
 node_index = self._tree[node_index][3]
 if node_index is None:
 return False
 return True
 return False

 def __eq__(self, other):
 return self._tree == other._tree

 def add(self, value):
 if len(self):
 node_index = 0
 while self._tree[node_index][0] != value:
 if value &lt; self._tree[node_index][0]:
 b = self._tree[node_index][2]
 k = 2
 else:
 b = self._tree[node_index][3]
 k = 3
 if b is None:
 self._tree[node_index][k] = len(self)
 self._tree.append([value, node_index, None, None])
 break
 node_index = b
 else:
 self._tree.append([value, None, None, None])

 def remove(self, value):
 if len(self):
 node_index = 0
 while self._tree[node_index][0] != value:
 if value &lt; self._tree[node_index][0]:
 node_index = self._tree[node_index][2]
 else:
 node_index = self._tree[node_index][3]
 if node_index is None:
 raise KeyError
 if self._tree[node_index][2] is not None:
 b, d = 2, 3
 elif self._tree[node_index][3] is not None:
 b, d = 3, 2
 else:
 i = node_index
 b = None
 if b is not None:
 i = self._tree[node_index][b]
 while self._tree[i][d] is not None:
 i = self._tree[i][d]
 p = self._tree[i][1]
 b = self._tree[i][b]
 if p == node_index:
 self._tree[p][5-d] = b
 else:
 self._tree[p][d] = b
 if b is not None:
 self._tree[b][1] = p
 self._tree[node_index][0] = self._tree[i][0]
 else:
 p = self._tree[i][1]
 if p is not None:
 if self._tree[p][2] == i:
 self._tree[p][2] = None
 else:
 self._tree[p][3] = None
 last = self._tree.pop()
 n = len(self)
 if i &lt; n:
 self._tree[i] = last[:]
 if last[2] is not None:
 self._tree[last[2]][1] = i
 if last[3] is not None:
 self._tree[last[3]][1] = i
 if self._tree[last[1]][2] == n:
 self._tree[last[1]][2] = i
 else:
 self._tree[last[1]][3] = i
 else:
 raise KeyError

 def find(self, value):
 if len(self):
 node_index = 0
 while self._tree[node_index][0] != value:
 if value &lt; self._tree[node_index][0]:
 node_index = self._tree[node_index][2]
 else:
 node_index = self._tree[node_index][3]
 if node_index is None:
 return None
 return Node(*self._tree[node_index])
 return None
</code></pre>

I've added a parent attribute so that you can remove any node and maintain the BST structure.

Sorry for the readability, especially for the "remove" function. Basically, when a node is removed, we pop the tree array and replace it with the last element (except if we wanted to remove the last node). To maintain the BST structure, the removed node is replaced with the max of its left children or the min of its right children and some operations have to be done in order to keep the indexes valid but it's fast enough.

I used this technique for more advanced stuff to build some big words dictionaries with an internal radix trie and I was able to divide memory consumption by 7-8 (you can see an example here: <a href="https://gist.github.com/fbparis/b3ddd5673b603b42c880974b23db7cda" rel="nofollow noreferrer">https://gist.github.com/fbparis/b3ddd5673b603b42c880974b23db7cda</a>)

blocks|key|1283365|text|我想展示@apadana方法的一个变体，当有相当多的节点时，该方法更有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283366|'''
Suppose+we+have+the+following+tree
++++++10
++++/++++\
++11++++++9
+/++\+++++/+\
7+++12++15+++8
'''
#+Step+1+-+Create+nodes+-+Use+a+list+instead+of+defining+each+node+separately
nlist+=+[10,11,7,9,15,8,12];+n+=+[]
for+i+in+range(len(nlist)):+n.append(Node(nlist[i]))

#+Step+2+-+Set+each+node+position
n[0].left++=+n[1]
n[1].left+=+n[2]
n[0].right+=+n[3]
n[3].left+=+n[4]
n[3].right+=+n[5]
n[1].right+=+n[6]|code-block|syntax|javascript|1283367|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I want to show a variation of @apadana's method, which is more useful when there is a considerable number of nodes:

<pre><code>'''
Suppose we have the following tree
 10
 / \
 11 9
 / \ / \
7 12 15 8
'''
# Step 1 - Create nodes - Use a list instead of defining each node separately
nlist = [10,11,7,9,15,8,12]; n = []
for i in range(len(nlist)): n.append(Node(nlist[i]))

# Step 2 - Set each node position
n[0].left = n[1]
n[1].left = n[2]
n[0].right = n[3]
n[3].left = n[4]
n[3].right = n[5]
n[1].right = n[6]
</code></pre>

blocks|key|1068687|text|class+Node:
++++"""
++++single+Node+for+tree
++++"""

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


class+binaryTree:
++++"""
++++binary+tree+implementation
++++"""

++++def+__init__(self):
++++++++self.root+=+None

++++def+push(self,+element,+node=None):
++++++++if+node+is+None:
++++++++++++node+=+self.root

++++++++if+self.root+is+None:
++++++++++++self.root+=+Node(element)

++++++++else:
++++++++++++if+element+<+node.data:
++++++++++++++++if+node.left+is+not+None:
++++++++++++++++++++self.push(element,+node.left)
++++++++++++++++else:
++++++++++++++++++++node.left+=+Node(element)
++++++++++++else:
++++++++++++++++if+node.right+is+not+None:
++++++++++++++++++++self.push(element,+node.right)
++++++++++++++++else:
++++++++++++++++++++node.right+=+Node(element)

++++def+__str__(self):
++++++++self.printInorder(self.root)
++++++++return+"\n"

++++def+printInorder(self,+node):
++++++++"""
++++++++print+tree+in+inorder
++++++++"""
++++++++if+node+is+not+None:
++++++++++++self.printInorder(node.left)
++++++++++++print(node.data)
++++++++++++self.printInorder(node.right)


def+main():
++++"""
++++Main+code+and+logic+comes+here
++++"""
++++tree+=+binaryTree()
++++tree.push(5)
++++tree.push(3)
++++tree.push(1)
++++tree.push(3)
++++tree.push(0)
++++tree.push(2)
++++tree.push(9)
++++tree.push(10)
++++print(tree)


if+__name__+==+"__main__":
++++main()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1068688|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class Node:
 &quot;&quot;&quot;
 single Node for tree
 &quot;&quot;&quot;

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


class binaryTree:
 &quot;&quot;&quot;
 binary tree implementation
 &quot;&quot;&quot;

 def __init__(self):
 self.root = None

 def push(self, element, node=None):
 if node is None:
 node = self.root

 if self.root is None:
 self.root = Node(element)

 else:
 if element &lt; node.data:
 if node.left is not None:
 self.push(element, node.left)
 else:
 node.left = Node(element)
 else:
 if node.right is not None:
 self.push(element, node.right)
 else:
 node.right = Node(element)

 def __str__(self):
 self.printInorder(self.root)
 return &quot;\n&quot;

 def printInorder(self, node):
 &quot;&quot;&quot;
 print tree in inorder
 &quot;&quot;&quot;
 if node is not None:
 self.printInorder(node.left)
 print(node.data)
 self.printInorder(node.right)


def main():
 &quot;&quot;&quot;
 Main code and logic comes here
 &quot;&quot;&quot;
 tree = binaryTree()
 tree.push(5)
 tree.push(3)
 tree.push(1)
 tree.push(3)
 tree.push(0)
 tree.push(2)
 tree.push(9)
 tree.push(10)
 print(tree)


if __name__ == &quot;__main__&quot;:
 main()
</code></pre>

blocks|key|1068755|text|您可以用面向对象的方法(或构建类)在Python中创建自己的BinaryTree数据结构。你可以在这里分开两个类:+Node和BinaryTree。"+node“类将负责为BinaryTree创建单独的节点对象，而"BinaryTree”类是在"Node“类之上实现二叉树所需的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068756|这是我在学习的时候写的代码：|1068757|class+TreeNode:

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

++++def+__str__(self):
++++++++return+f'Node(Data={self.data},+Left={self.left},+Right={self.right})'

++++def+__repr__(self):
++++++++return+self.__str__()

++++def+get_data(self):
++++++++return+self.data

++++def+set_data(self,+data):
++++++++self.data+=+data

++++def+get_left(self):
++++++++return+self.left

++++def+set_left(self,+left):
++++++++self.left+=+left

++++def+get_right(self):
++++++++return+self.right

++++def+set_right(self,+right):
++++++++self.right+=+right

class+BinaryTree:

++++def+__init__(self,+root=None):
++++++++self.root+=+TreeNode(root)

++++def+__str__(self):
++++++++return+f'BinaryTree({self.root})'

++++def+__repr__(self):
++++++++return+f'BinaryTree({self.root})'

++++def+insert(self,+data):
++++++++#+if+empty+tree
++++++++if+self.root.get_data()+is+None:
++++++++++++return+self.root.set_data(data)
++++++++new_node+=+TreeNode(data)
++++++++current+=+self.root
++++++++while+True:
++++++++++++if+data+<+current.get_data():
++++++++++++++++if+current.get_left()+is+None:
++++++++++++++++++++return+current.set_left(new_node)
++++++++++++++++current+=+current.get_left()
++++++++++++++++continue
++++++++++++elif+data+>+current.get_data():
++++++++++++++++if+current.get_right()+is+None:
++++++++++++++++++++return+current.set_right(new_node)
++++++++++++++++current+=+current.get_right()
++++++++++++++++continue
++++++++++++return

++++#+still+needs+other+methods+like+the+delete+method,+but+you+can
++++#+try+it+out+yourself
++++def+delete(self,+node):
++++++++pass

def+main():
++++myTree+=+BinaryTree()
++++myTree.insert(5)
++++myTree.insert(3)
++++myTree.insert(4)
++++myTree.insert(2)
++++myTree.insert(8)
++++myTree.insert(9)
++++myTree.insert(6)
++++print(myTree)

if+__name__+==+'__main__':
++++main()|code-block|syntax|javascript|1068758|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can make your own BinaryTree data structure in Python the OOP way (or building a class).
You can separate two class in here: Node and BinaryTree.
The &quot;Node&quot; class will be responsible for creating individual node objects for the BinaryTree while the &quot;BinaryTree&quot; class is what you'll need to implement the binary tree on top of the &quot;Node&quot; class.
Here's what I coded when I'm studying it back then:
<pre><code>class TreeNode:

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

 def __str__(self):
 return f'Node(Data={self.data}, Left={self.left}, Right={self.right})'

 def __repr__(self):
 return self.__str__()

 def get_data(self):
 return self.data

 def set_data(self, data):
 self.data = data

 def get_left(self):
 return self.left

 def set_left(self, left):
 self.left = left

 def get_right(self):
 return self.right

 def set_right(self, right):
 self.right = right

class BinaryTree:

 def __init__(self, root=None):
 self.root = TreeNode(root)

 def __str__(self):
 return f'BinaryTree({self.root})'

 def __repr__(self):
 return f'BinaryTree({self.root})'

 def insert(self, data):
 # if empty tree
 if self.root.get_data() is None:
 return self.root.set_data(data)
 new_node = TreeNode(data)
 current = self.root
 while True:
 if data &lt; current.get_data():
 if current.get_left() is None:
 return current.set_left(new_node)
 current = current.get_left()
 continue
 elif data &gt; current.get_data():
 if current.get_right() is None:
 return current.set_right(new_node)
 current = current.get_right()
 continue
 return

 # still needs other methods like the delete method, but you can
 # try it out yourself
 def delete(self, node):
 pass

def main():
 myTree = BinaryTree()
 myTree.insert(5)
 myTree.insert(3)
 myTree.insert(4)
 myTree.insert(2)
 myTree.insert(8)
 myTree.insert(9)
 myTree.insert(6)
 print(myTree)

if __name__ == '__main__':
 main()
</code></pre>

blocks|key|1068816|text|在节点顺序上，左子节点在右子节点之前。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068817|每个节点被认为是左右树的根节点。编写一个类来轻松创建节点：|1068818|class+_Node:
++++#slots+are+class+level+member,efficiently+allocates+memory+for+instance+variables
++++__slots__='_element','_left','_right'
++++def+__init__(self,element,left=None,right=None):
+++++#+left+is+not+a+node,+left+is+the+left+sub+Binary+Tree
+++++#+right+is+the+right+sub+Binary+Tree
++++++++self._element=element
++++++++self._left=left
++++++++self._right=right|code-block|syntax|javascript|1068819|这里我们编写二进制类：|1068820|class+BinaryTree:
++++def+__init__(self):
++++++++self._root=None
++++def+make_tree(self,e,left,right):+#+left=left-subtree,+right=right-subtree
++++++++#+we+start+the+tree+from+leaf+nodes..+since+it+has+no+left+and+right+subtrees,+left+and+right+null+
++++++++#+x.maketree(B,null,null)=[Q,B,Q]+this+is+node+x
++++++++#+y.maketree(C,null,null)=[Q,C,Q]
++++++++#+z.maketree(A,x,y)++"z"+is+the+parent+of+"x"+and+"y"
++++++++#+each+node+is+the+root+of+the+binary+tree
++++++++#+each+subtree+is+also+considered+to+be+Binary+Tree
++++++++self._root=_Node(e,left._root,right._root)+
++++#+inorder+similar+to+infix:A%2BB.+visit+left+first,+then+root,+then+right
++++def+inorder(self,troot):
++++++++if+troot:
++++++++++++self.inorder(troot._left)
++++++++++++print(troot._element,end='+')
++++++++++++self.inorder(troot._right)
+++#+preorder+similar+to+prefix.+%2BAB,+visit+root+first,then+left,+then+right
++++def+preorder(self,troot):
++++++++if+troot:
++++++++++++print(troot._element,end='+')
++++++++++++self.preorder(troot._left)
++++++++++++self.preorder(troot._right)
+++#+postorder+similar+to+postfix.+left+first,+then+right,+then+root
++++def+postorder(self,troot):
++++++++if+troot:
++++++++++++self.postorder(troot._left)
++++++++++++self.postorder(troot._right)
++++++++++++print(troot._element,end='+')++
+++#+count+the+number+of+nodes+recursively
+++#+recursive+calls+break+the+problem+into+smallest+sub+problems
+++#+we+are+recursively+asking+each+node,+how+many+children+does+each+node+have
++#+if+a+node+does+not+have+any+child,+we+count+that+node,+that+is+why+add+%2B1.+x%2By%2B1
++++def+count(self,troot):
++++++++if+troot:
++++++++++++x=self.count(troot._left)
++++++++++++print("x",x)
++++++++++++y=self.count(troot._right)
++++++++++++print("y",y)
++++++++++++print("x%2By",x%2By)
++++++++++++#+we+add+%2B1+because+we+have+to+count+the+root+
++++++++++++return+x%2By%2B1
++++++++return+0
++++def+height(self,troot):
++++++++if+troot:
++++++++++++x=self.height(troot._left)
++++++++++++y=self.height(troot._right)
++++++++++++if+x>y:
++++++++++++++++return+x%2B1
++++++++++++else:
++++++++++++++++return+y%2B1
++++++++return+0|1068821|现在创建二叉树：|1068822|创建6个子二叉树|1068823|x=BinaryTree()
y=BinaryTree()
z=BinaryTree()
r=BinaryTree()
s=BinaryTree()
t=BinaryTree()
a=BinaryTree()+#+null+binary+tree|1068824|首先制作叶节点，40和60|1068825|#+if+a+tree+has+only+root+node,+it+is+still+binary+tree
x.make_tree(40,a,a)
y.make_tree(60,a,a)|1068826|创建内部节点|1068827|z.make_tree(20,x,a)+#left+internal
r.make_tree(50,a,y)+#right+internal
s.make_tree(30,r,a)
t.make_tree(10,z,s)|1068828|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

The left child precedes the right child in order of Nodes.
Each node is considered to be the root node of the left and right tree. Write a class to create nodes easily:
<pre><code>class _Node:
 #slots are class level member,efficiently allocates memory for instance variables
 __slots__='_element','_left','_right'
 def __init__(self,element,left=None,right=None):
 # left is not a node, left is the left sub Binary Tree
 # right is the right sub Binary Tree
 self._element=element
 self._left=left
 self._right=right
</code></pre>
Here we write the Binary class:
<pre><code>class BinaryTree:
 def __init__(self):
 self._root=None
 def make_tree(self,e,left,right): # left=left-subtree, right=right-subtree
 # we start the tree from leaf nodes.. since it has no left and right subtrees, left and right null 
 # x.maketree(B,null,null)=[Q,B,Q] this is node x
 # y.maketree(C,null,null)=[Q,C,Q]
 # z.maketree(A,x,y) &quot;z&quot; is the parent of &quot;x&quot; and &quot;y&quot;
 # each node is the root of the binary tree
 # each subtree is also considered to be Binary Tree
 self._root=_Node(e,left._root,right._root) 
 # inorder similar to infix:A+B. visit left first, then root, then right
 def inorder(self,troot):
 if troot:
 self.inorder(troot._left)
 print(troot._element,end=' ')
 self.inorder(troot._right)
 # preorder similar to prefix. +AB, visit root first,then left, then right
 def preorder(self,troot):
 if troot:
 print(troot._element,end=' ')
 self.preorder(troot._left)
 self.preorder(troot._right)
 # postorder similar to postfix. left first, then right, then root
 def postorder(self,troot):
 if troot:
 self.postorder(troot._left)
 self.postorder(troot._right)
 print(troot._element,end=' ') 
 # count the number of nodes recursively
 # recursive calls break the problem into smallest sub problems
 # we are recursively asking each node, how many children does each node have
 # if a node does not have any child, we count that node, that is why add +1. x+y+1
 def count(self,troot):
 if troot:
 x=self.count(troot._left)
 print(&quot;x&quot;,x)
 y=self.count(troot._right)
 print(&quot;y&quot;,y)
 print(&quot;x+y&quot;,x+y)
 # we add +1 because we have to count the root 
 return x+y+1
 return 0
 def height(self,troot):
 if troot:
 x=self.height(troot._left)
 y=self.height(troot._right)
 if x&gt;y:
 return x+1
 else:
 return y+1
 return 0
</code></pre>
now create the binary tree:
<h2 id="creating-6-sub-binary-trees-kfza">creating 6 sub binary trees</h2>
<pre><code>x=BinaryTree()
y=BinaryTree()
z=BinaryTree()
r=BinaryTree()
s=BinaryTree()
t=BinaryTree()
a=BinaryTree() # null binary tree
</code></pre>
<h2 id="first-make-leaf-nodes-40-and-60-jnv0">first make leaf nodes, 40 and 60</h2>
<pre><code># if a tree has only root node, it is still binary tree
x.make_tree(40,a,a)
y.make_tree(60,a,a)
</code></pre>
<h2 id="creating-internal-nodes-ac8q">creating internal nodes</h2>
<pre><code>z.make_tree(20,x,a) #left internal
r.make_tree(50,a,y) #right internal
s.make_tree(30,r,a)
t.make_tree(10,z,s)
</code></pre>

Which is the best data structure that can be used to implement a binary tree in Python?

How to implement a binary tree?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Python中，可以用来实现二叉树的最佳数据结构是什么？

问如何实现二叉树？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何实现二叉树？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何实现二叉树？
EN