python二叉树查找索引

㈠ python二叉树算法

定义一颗二叉树，请看官自行想象其形状

class BinNode( ):
def __init__( self, val ):
self.lchild = None
self.rchild = None
self.value = val

binNode1 = BinNode( 1 )
binNode2 = BinNode( 2 )
binNode3 = BinNode( 3 )
binNode4 = BinNode( 4 )
binNode5 = BinNode( 5 )
binNode6 = BinNode( 6 )

binNode1.lchild = binNode2
binNode1.rchild = binNode3
binNode2.lchild = binNode4
binNode2.rchild = binNode5
binNode3.lchild = binNode6

㈡ python 二叉树是怎么实现的

#coding:utf-8
#author:Elvis

classTreeNode(object):
def__init__(self):
self.data='#'
self.l_child=None
self.r_child=None

classTree(TreeNode):
#createatree
defcreate_tree(self,tree):
data=raw_input('->')
ifdata=='#':
tree=None
else:
tree.data=data
tree.l_child=TreeNode()
self.create_tree(tree.l_child)
tree.r_child=TreeNode()
self.create_tree(tree.r_child)

#visitatreenode
defvisit(self,tree):
#输入#号代表空树
iftree.dataisnot'#':
printstr(tree.data)+'	',
#先序遍历
defpre_order(self,tree):
iftreeisnotNone:
self.visit(tree)
self.pre_order(tree.l_child)
self.pre_order(tree.r_child)

#中序遍历
defin_order(self,tree):
iftreeisnotNone:
self.in_order(tree.l_child)
self.visit(tree)
self.in_order(tree.r_child)

#后序遍历
defpost_order(self,tree):
iftreeisnotNone:
self.post_order(tree.l_child)
self.post_order(tree.r_child)
self.visit(tree)

t=TreeNode()
tree=Tree()
tree.create_tree(t)
tree.pre_order(t)
print'
'
tree.in_order(t)
print'
'
tree.post_order(t)

㈢ 二叉树索引原理是什么

索引是为检索而存在的。如一些书籍的末尾就专门附有索引，指明了某个关键字在正文中的出现的页码位置，方便我们查找，但大多数的书籍只有目录，目录不是索引，只是书中内容的排序，并不提供真正的检索功能。可见建立索引要单独占用空间；索引也并不是必须要建立的，它们只是为更好、更快的检索和定位关键字而存在。
再进一步说，我们要在图书馆中查阅图书，该怎么办呢？图书馆的前台有很多叫做索引卡片柜的小柜子，里面分了若干的类别供我们检索图书，比如你可以用书名的笔画顺序或者拼音顺序作为查找的依据，你还可以从作者名的笔画顺序或拼音顺序去查询想要的图书，反正有许多检索方式，但有一点很明白，书库中的书并没有按照这些卡片柜中的顺序排列——虽然理论上可以这样做，事实上，所有图书的脊背上都人工的粘贴了一个特定的编号①，它们是以这个顺序在排列。索引卡片中并没有指明这本书摆放在书库中的第几个书架的第几本，仅仅指明了这个特定的编号。管理员则根据这一编号将请求的图书返回到读者手中。这是很形象的例子，以下的讲解将会反复用到它。

㈣ python 二叉树实现四则运算

#!/usr/bin/python#* encoding=utf-8s = "20-5*(0+1)*5^(6-2^2)" c = 0top = [0,s[c],0]op = [["0","1","2","3","4","5","6","7","8","9"],["+","-"],["*","/"],["^"]] def getLev(ch): for c1 in range(0, len(op)): for c2 in range(0, len(op[c1])): if (op[c1][c2]==ch): return c1 elif (len(ch)>1): match = 0 for c3 in range(0, len(ch)): if (getLev(ch[c3])>=0): match+=1 if (match==len(ch)):return c1 return -1

㈤ python怎么做二叉查找树

可以的，和C++中类的设计差不多，以下是二叉树的遍历
class BTree:
def __init__(self,value):
self.left=None
self.data=value
self.right=None

def insertLeft(self,value):
self.left=BTree(value)
return self.left
#return BTree(value)

def insertRight(self,value):
self.right=BTree(value)
return self.right

def show(self):
print self.data

def preOrder(node):
node.show()
if node.left:
preOrder(node.left)
if node.right:
preOrder(node.right)

def inOrder(node):
if node:
if node.left:
inOrder(node.left)
node.show()
if node.right:
inOrder(node.right)

if __name__=='__main__':
Root=BTree('root')
A=Root.insertLeft('A')
C=A.insertLeft('C')
D=A.insertRight('D')
F=D.insertLeft('F')
G=D.insertRight('G')
B=Root.insertRight('B')
E=B.insertRight('E')

preOrder(Root)
print 'This is binary tree in-traversal'
inOrder(Root)

㈥ python 二叉树实现思想

第一 ：return 的缩进不对 ，

ifself.root==None:
self.root=node
return#如果这里不缩进，下面的语句无意义，直接返回，不会执行。

while queue这个循环的作用的是从root根结点开始，向下查找第一个左(右)子结点为空的结点，将node插入这个位置,queue的作用是将查找到的非空子结点保存在queue中，然后依次向下查找这些子结点的左右子结点

㈦ python 查找二叉树是否有子树

python中的二叉树模块内容：
BinaryTree：非平衡二叉树
AVLTree：平衡的AVL树
RBTree：平衡的红黑树
以上是用python写的，相面的模块是用c写的，并且可以做为Cython的包。
FastBinaryTree
FastAVLTree
FastRBTree
特别需要说明的是：树往往要比python内置的dict类慢一些，但是它中的所有数据都是按照某个关键词进行排序的，故在某些情况下是必须使用的。
安装和使用
安装方法
安装环境：
ubuntu12.04, python 2.7.6

㈧ Python编程求解二叉树中和为某一值的路径代

1、如果只有根节点或者找到叶子节点，我们就把其对应的val值返回
2、如果不是叶子节点，我们分别对根节点的左子树、右子树进行递归，直到找到叶子结点。然后遍历把叶子结点和父节点对应的val组成的序列返回上一层；

㈨ python语言基础知识是什么

如下：

一、Python语言基础

Python核心：Python数据基本运算、语句、容器、函数

Python 面向对象编程：OOA、OOD、OOP、天龙八部技能系统框架 设计 Python高级：模块、包、函数式编程、文件。

二、Python高级软件开发技术

Linux操作系统 ：Linux常用命令、编辑工具、vim/Pycharm

数据结构与算法 ：链表、栈和队列、树和二叉树、查找排序

IO网络编程：文件操作、字节流读写、网络协议、套接 字、TCP/UDP

并发编程：多进程、进程池、进程通信、多线程、线程锁、多任务并发、IO模型、协程

Python 正则表达式：正则表达式、贪婪模和非贪婪模式、re模块

MySQL基础：数据库应用、SQL语言、Mysql增删改查、 pymysql模块

三、Python Web全栈式工程师

HTML/CSS HTML5标签，CSS选择器，CSS样式属性以 及值

Java ：JS流程控制，DOM，BOM，JQuery API

MySQL高级：MySQL索引、事务、引擎、优化、pymysql 模块使用

Python Django 框架：Django、模板、视图、模型、请求对象等

Ajax Ajax,：JSON, Jquery对Ajax的支持, 跨域访问

四、Python 爬虫

Redis：Redis、string、hash、list、set、zset、 Python与MySQL和Redis结合

爬虫、HTTP、BeautifulSoup,XPath,Scrapy其实无论是学习什么知识，都要有一个对学习目标的清楚认识。 只有这样才能朝着目标持续前进，少走弯路，从学习中得到不断的提升，享受python学习计划的过程。

㈩ 求Python二叉树的几个算法 求几个二叉树的method！ 1) 给一个值，然后在树中找出该值

你好：

二叉树算法，网上是比较多的；

可能按照你的需求不是很多：

下面是我用的一个，不过你可以借鉴一下的：

#-*-coding:cp936-*-
importos
classNode(object):
"""docstringforNode"""
def__init__(self,v=None,left=None,right=None,parent=None):
self.value=v
self.left=left
self.right=right
self.parent=parent
classBTree(object):
"""docstringforBtTee"""
def__init__(self):
self.root=None
self.size=0
definsert(self,node):
n=self.root
ifn==None:
self.root=node
return
whileTrue:
ifnode.value<=n.value:
ifn.left==None:
node.parent=n
n.left=node
break
else:
n=n.left
ifnode.value>n.value:
ifn.right==None:
n.parent=n
n.right=node
break
else:
n=n.right
deffind(self,v):
n=self.root#http://yige.org
whileTrue:
ifn==None:
returnNone
ifv==n.value:
returnn
ifv<n.value:
n=n.left
continue
ifv>n.value:
n=n.right
deffind_successor(node):
'''查找后继结点'''
assertnode!=Noneandnode.right!=None
n=node.right
whilen.left!=None:
n=n.left
returnn
defdelete(self,v):
n=self.find(v)
print"delete:",n.value
del_parent=n.parent
ifdel_parent==None:
self.root=None;
return
ifn!=None:
ifn.left!=Noneandn.right!=None:
succ_node=find_successor(n)
parent=succ_node.parent
ifsucc_node==parent.left:
#ifsucc_nodeisleftsubtree
parent.left=None
ifsucc_node==parent.right:
#ifsucc_nodeisrightsubtree
parent.right=None
ifdel_parent.left==n:
del_parent.left=succ_node
ifdel_parent.right==n:
del_parent.right=succ_node
succ_node.parent=n.parent
succ_node.left=n.left
succ_node.right=n.right
deln
elifn.left!=Noneorn.right!=None:
ifn.left!=None:
node=n.left
else:
node=n.right
node.parent=n.parent
ifdel_parent.left==n:
del_parent.left=node
ifdel_parent.right==n:
del_parent.right=node
deln
else:
ifdel_parent.left==n:
del_parent.left=None
ifdel_parent.right==n:
del_parent.right=None
deftranverse(self):
defpnode(node):
ifnode==None:
return
ifnode.left!=None:
pnode(node.left)
printnode.value
ifnode.right!=None:
pnode(node.right)
pnode(self.root)
defgetopts():
importoptparse,locale
parser=optparse.OptionParser()
parser.add_option("-i","--input",dest="input",help=u"helpname",metavar="INPUT")
(options,args)=parser.parse_args()
#printoptions.input
return(options.input)
if__name__=='__main__':
al=[23,45,67,12,78,90,11,33,55,66,89,88,5,6,7,8,9,0,1,2,678]
bt=BTree()
forxinal:
bt.insert(Node(x))
bt.delete(12)
bt.tranverse()
n=bt.find(12)
ifn!=None:
print"findvalud:",n.value