多叉树算法
1. 求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
2. 求一个python的三叉树算法
这是网络上的一个版本，我自己做了一点修改，这是一个n叉树，希望对你有所帮助
#!/usr/bin/python
#-*-coding:utf-8-*-
'''
Createdon2014-3-26
@author:qcq
'''
#==============================================================================
#tree.py:
#==============================================================================
#--
#$Revision:1.7$
#$Date:2000/03/2922:36:12$
#modifiedbyqcqin2014/3/27
#modifiedbyqcqin2014/4/23增加了遍历树的非递归版本的广度优先和深度优先
#--
#================================================================
#Contents
#----------------------------------------------------------------
#classTree:Genericn-arytreenodeobject
#classNodeId:Representsthepathtoanodeinann-arytree
#----------------------------------------------------------------
#importstring
classTree:
"""Genericn-arytreenodeobject
Childrenareadditive;noprovisionfordeletingthem.
:0forthefirst
childadded,1forthesecond,andsoon.
modifiedbyqcqin2014/3/27.
Exports:
Tree(parent,value=None)Constructor
.parentIfthisistherootnode,None,otherwise
theparent'sTreeobject.
.childListListofchildren,zeroormoreTreeobjects.
.valueValuepassedtoconstructor;canbeanytype.
.birthOrderIfthisistherootnode,0,otherwisethe
indexofthischildintheparent's.childList
.nChildren()Returnsthenumberofself'schildren.
.nthChild(n)Returnsthenthchild;raisesIndexErrorif
nisnotavalidchildnumber.
.fullPath():.
.nodeId():ReturnspathtoselfasaNodeId.
"""
#---Tree.__init__---
def__init__(self,parent,value=None):
"""ConstructorforaTreeobject.
[if(parentisNoneoraTreeobject)->
if(parentisNone)->
,nochildren,
andvalue(value)
else->
ofparent(parent)andnochildren,andvalue(value)
]
"""
#--1--
self.parent=parent
self.value=value
self.childList=[]
#--2--
#-[if(parentisNone)->
#self.birthOrder:=0
#else->
#parent:=
#self.birthOrder:=sizeofparent's.childList
#-]
ifparentisNone:
self.birthOrder=0
else:
self.birthOrder=len(parent.childList)
parent.childList.append(self)
#---Tree.nChildren---
defnChildren(self):
"""[
]
"""
returnlen(self.childList)
#---Tree.nthChild---
defnthChild(self,n):
"""[if(nisaninteger)->
if(0<=n<(numberofself'schildren)->
returnself's(n)thchild,countingfrom0
else->
raiseIndexError
]
"""
returnself.childList[n]
#---Tree.fullPath---
deffullPath(self):
""".
[returnasequence[c0,c1,...,ci]suchthatselfis
root.nthChild(c0).nthChild(c1).....nthChild(ci),or
anemptylistifselfistheroot]
"""
#--1--
result=[]
parent=self.parent
kid=self
#--2--
#[result+:=childnumbersfromparenttoroot,in
#reverseorder]
whileparent:
result.insert(0,kid.birthOrder)
parent,kid=parent.parent,parent
#--3--
returnresult
#---Tree.nodeId---
defnodeId(self):
""".
"""
#--1--
#[fullPath:=sequence[c0,c1,...,ci]suchthatselfis
#root.nthChild(c0).nthChild(c1).....nthChild(ci),or
#anemptylistifselfistheroot]
fullPath=self.fullPath()
#--2--
returnNodeId(fullPath)
defequals(self,node):
'''
'''
returnself.value==node.value
#===========================================================================
#deletethenodefromthetree
#===========================================================================
defdelete(self):
ifself.parentisNone:
return
else:
#temp=self.birthOrder
'''
ifdeletethemiddletreeobject,
.
'''
self.parent.childList.remove(self.parent.childList[self.birthOrder])
fori,jinzip(range(self.birthOrder+1,self.parent.nChildren()),self.parent.childList[self.birthOrder+1:]):
j.birthOrder=j.birthOrder-1
defupdate(self,value):
'''
'''
self.value=value
def__str__(self):
return"The%dchildwithvalue%d"%(self.birthOrder,self.value)#-----classNodeId-----
classNodeId:
""".
Exports:
NodeId(path):
[->
-id]
.path:[aspassedtoconstructor]
.__str__():[returnselfasastring]
.find(root):
[ifrootisaTreeobject->
treerootedat(root)->
returnthe.valueofthatnode
else->
returnNone]
.isOnPath(node):
[ifnodeisaTreeobject->
->
return1
else->
return0]
"""
#---NodeId.__init__---
def__init__(self,path):
"""ConstructorfortheNodeIdobject
"""
self.path=path
#---NodeId.__str__---
def__str__(self):
"""Returnselfindisplayableform
"""
#--1--
#[L:=alistoftheelementsofself.pathconvertedtostrings]
L=map(str,self.path)
#--2--
#["/"]
returnstring.join(L,"/")
#---NodeId.find---
deffind(self,node):
"""
"""
returnself.__reFind(node,0)
#---NodeId.__reFind---
def__reFind(self,node,i):
"""Recursivenodefindingroutine.Startsatself.path[i:].
[if(nodeisaTreeobject)
and(0<=i<=len(self.path))->
ifi==len(self.path)->
returnnode'svalue
elseifself.path[i:]describesapathfromnode
tosometreeobjectT->
returnT
else->
returnNone]
"""
#--1--
ifi>=len(self.path):
returnnode.value#We'rethere!
else:
childNo=self.path[i]
#--2--
#[->
#child:=thatchildnode
#else->
#returnNone]
try:
child=node.nthChild(childNo)
exceptIndexError:
returnNone
#--3--
#[if(i+1)==len(self.path)->
#returnchild
#elseifself.path[i+1:]describesapathfromnodeto
#sometreeobjectT->
#returnT
#else->
#returnNone]
returnself.__reFind(child,i+1)
#---NodeId.isOnPath---
defisOnPath(self,node):
"""Isself'spathtoorthroughthegivennode?
"""
#--1--
#[nodePath:=pathlistfornode]
nodePath=node.fullPath()
#--2--
#[ifnodePathisaprefixof,oridenticaltoself.path->
#return1
#else->
#return0]
iflen(nodePath)>len(self.path):
return0#Nodeisdeeperthanself.path
foriinrange(len(nodePath)):
ifnodePath[i]!=self.path[i]:
return0#Nodeisadifferentroutethanself.path
return1
3. 关于算法中的二叉树，，，
满二叉树是没有度为1的结点。
完全二叉树定义:
若设二叉树的高度为h，除第 h 层外，其它各层 (1~h-1) 的结点数都达到最大个数，第 h 层从右向左连续缺若干结点，这就是完全二叉树。
完全二叉树叶子结点的算法:
如果一棵具有n个结点的深度为k的二叉树，它的每一个结点都与深度为k的满二叉树中编号为1~n的结点一一对应，这棵二叉树称为完全二叉树。
可以根据公式进行推导，假设n0是度为0的结点总数(即叶子结点数)，n1是度为1的结点总数，n2是度为2的结点总数，由二叉树的性质可知:n0=n2+1，则n= n0+n1+n2(其中n为完全二叉树的结点总数)，由上述公式把n2消去得:n= 2n0+n1-1，由于完全二叉树中度为1的结点数只有两种可能0或1，由此得到n0=(n+1)/2或n0=n/2，合并成一个公式:n0=(n+1)/2 ，就可根据完全二叉树的结点总数计算出叶子结点数。
因此叶子结点数是(839+1)/2=420
4. 关于二叉树的算法.C++
#include<vector>
#include<iostream>
usingnamespacestd;
structTreeNode
{
intval;
TreeNode*left;
TreeNode*right;
TreeNode(intx):val(x),left(NULL),right(NULL){} //constructionfunction
};
voidfun(TreeNode*root,vector<TreeNode*>&vt)
{
if(root==nullptr)
return;
vt.push_back(root);
fun(root->left,vt);
fun(root->right,vt);
for(autoele:vt)
cout<<ele->val<<"";
cout<<endl;
vt.pop_back();
}
intmain()
{
TreeNode*root=newTreeNode(0);
root->left=newTreeNode(1);
root->right=newTreeNode(2);
root->left->right=newTreeNode(3);
root->left->right->left=newTreeNode(4);
root->right->left=newTreeNode(5);
root->right->right=newTreeNode(6);
vector<TreeNode*>vt;
fun(root,vt);
}
5. 二叉树算法是什么
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。
二叉树的第i层至多有2^（i 1）个结点；深度为k的二叉树至多有2^k 1个结点；对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0 = n2 + 1。二叉树算法常被用于实现二叉查找树和二叉堆。
二叉树是每个节点最多有两个子树的有序树。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。
(5)多叉树算法扩展阅读：
二叉树也是递归定义的，其结点有左右子树之分，逻辑上二叉树算法有五种基本形态：
1、空二叉树——(a)
2、只有一个根结点的二叉树——(b);
3、右子树为空的二叉树——(c);
4、左子树为空的二叉树——(d);
5、完全二叉树——(e)
注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。
6. 关于二叉树遍历算法的问题，一个二叉树求结点个数的问题，
意思就是这样啊，体现的就是分治策略，本来二叉树就可以简化为左子树+根+右子树
推而广之，很多二叉树的基本算法都是通过遍历来完成的，只是遍历的方法可能不一定是后序的
另外，按照定义，求二叉树的高度不是左右子树高度的和，而是左右子树高度的最大值，最后返回这个最大值加1，空二叉树就是0了
7. 二叉树的深度算法怎么算啊
二叉树的深度算法：
一、递归实现基本思想：
为了求得树的深度，可以先求左右子树的深度，取二者较大者加1即是树的深度，递归返回的条件是若节点为空，返回0
算法：
1
int
FindTreeDeep(BinTree
BT){
2
int
deep=0;
3
if(BT){
4
int
lchilddeep=FindTreeDeep(BT->lchild);
5
int
rchilddeep=FindTreeDeep(BT->rchild);
6
deep=lchilddeep>=rchilddeep?lchilddeep+1:rchilddeep+1;
7
}
8
return
deep;
9
}
二、非递归实现基本思想：
受后续遍历二叉树思想的启发，想到可以利用后续遍历的方法来求二叉树的深度，在每一次输出的地方替换成算栈S的大小，遍历结束后最大的栈S长度即是栈的深度。
算法的执行步骤如下：
（1）当树非空时，将指针p指向根节点，p为当前节点指针。
（2）将p压入栈S中，0压入栈tag中，并令p执行其左孩子。
（3）重复步骤（2），直到p为空。
（4）如果tag栈中的栈顶元素为1，跳至步骤（6）。从右子树返回
（5）如果tag栈中的栈顶元素为0，跳至步骤（7）。从左子树返回
（6）比较treedeep与栈的深度，取较大的赋给treedeep，对栈S和栈tag出栈操作，p指向NULL，并跳至步骤（8）。
（7）将p指向栈S栈顶元素的右孩子，弹出栈tag，并把1压入栈tag。（另外一种方法，直接修改栈tag栈顶的值为1也可以）
（8）循环（2）~（7），直到栈为空并且p为空
（9）返回treedeep，结束遍历
1
int
TreeDeep(BinTree
BT
){
2
int
treedeep=0;
3
stack
S;
4
stack
tag;
5
BinTree
p=BT;
6
while(p!=NULL||!isEmpty(S)){
7
while(p!=NULL){
8
push(S,p);
9
push(tag,0);
10
p=p->lchild;
11
}
12
if(Top(tag)==1){
13
deeptree=deeptree>S.length?deeptree:S.length;
14
pop(S);
15
pop(tag);
16
p=NULL;
17
}else{
18
p=Top(S);
19
p=p->rchild;
20
pop(tag);
21
push(tag,1);
22
}
23
}
24
return
deeptree;
25
}
8. 二叉树算法有哪些应用场景
二叉树常被用于实现二叉查找树和二叉堆。
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”。
根据不同的用途可分为：
1、完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
2、满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
3、平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
(8)多叉树算法扩展阅读
深度为h的二叉树最多有个结点(h>=1)，最少有h个结点。对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1。
有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系为若I为结点编号则 如果I>1，则其父结点的编号为I/2。如果2*I<=N，则其左孩子（即左子树的根结点）的编号为2*I。若2*I>N，则无左孩子。如果2*I+1<=N，则其右孩子的结点编号为2*I+1。
9. 二叉树的算法到底是怎么算啊！c语言一般都考些什么算法
我擦。二叉树的算法有很多，你说的是哪个？建议你去看严蔚敏的数据结构那本书。c语言一般考什么算法？你得先说明是什么考试可行？如果你是在上c语言课，期末考试的算法几乎涉及不到，考的都是些常用基础语法，算法也都是能从课本上找到原型的。如果你是计算机二级，爱莫能助，没考过。学计算机的，不需要考，只能祝你一切顺利咯
10. 请写出计算二叉树的深度的算法
typedef struct tree//二叉树的定义
{ char data; struct tree *lchild,*rchild; }TREE,*Tree;
void create(Tree t)//创建一棵二叉树
{ char ch; scanf("%c",&ch); if(ch=='#') t=NULL;
else { t->data=ch; create(t->lchild); create(t->rchild); }
}
int deep(Tree t)//深度算法
{ if(!t) return 0; else { ld=deep(t->lchild); rd=deep(t->rchild);
if(ld>rd) return rd+1; else return ld+1;
}
void main()//主函数
{ Tree t; create(t); printf("%d\n",deep(t)); }