python二叉树算法

1. 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

2. 四则运算表达式的求值 利用二叉树

实现该表达式的求值.要求的功能有(1)以字符的形式从终端输入语法正确,不含变量的实型数据算术四则运算表达式,创建用二叉树表达的表达式,(2)实现对表达式的求值

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

你好：
二叉树算法，网上是比较多的；
可能按照你的需求不是很多：
下面是我用的一个，不过你可以借鉴一下的：
# -*- coding: cp936 -*-import osclass Node(object):    """docstring for Node"""    def __init__(self, v = None, left = None, right=None, parent=None):        self.value = v        self.left = left        self.right = right        self.parent = parentclass BTree(object):    """docstring for BtTee """    def __init__(self):        self.root = None        self.size = 0    def insert(self, node):        n = self.root        if n == None:            self.root = node            return        while True:            if node.value  n.value:                if n.right == None:                    n.parent = n                    n.right = node                    break                else:                    n = n.right    def find(self, v):        n = self.root # http://yige.org        while True:            if n == None:                return None            if v == n.value:                return n            if v  n.value:                n = n.right    def find_successor(node):        '''查找后继结点'''        assert node != None and node.right != None        n = node.right        while n.left != None:            n = n.left        return n    def delete(self, v):        n = self.find(v)        print "delete:",n.value        del_parent = n.parent        if del_parent == None:            self.root = None;            return        if n != None:            if n.left != None and n.right != None:                succ_node = find_successor(n)                parent = succ_node.parent                if succ_node == parent.left:                    #if succ_node is left sub tree                    parent.left = None                if succ_node == parent.right:                    #if succ_node is right sub tree                    parent.right = None                if del_parent.left == n:                    del_parent.left = succ_node                if del_parent.right == n:                    del_parent.right = succ_node                succ_node.parent = n.parent                succ_node.left = n.left                succ_node.right = n.right                del n            elif n.left != None or n.right != None:                if n.left != None:                    node = n.left                else:                    node = n.right                node.parent = n.parent                if del_parent.left == n:                    del_parent.left = node                if del_parent.right == n:                    del_parent.right = node                del n            else:                if del_parent.left == n:                    del_parent.left = None                if del_parent.right == n:                    del_parent.right = None     def tranverse(self):        def pnode(node):            if node == None:                return            if node.left != None:                pnode(node.left)            print node.value            if node.right != None:                pnode(node.right)        pnode(self.root)def getopts():    import optparse, locale    parser = optparse.OptionParser()    parser.add_option("-i", "--input", dest="input", help=u"help name", metavar="INPUT")    (options, args) = parser.parse_args()    #print options.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()    for x in al :        bt.insert(Node(x))    bt.delete(12)    bt.tranverse()    n = bt.find(12)    if n != None:        print "find valud:",n.value

4. Python怎么实现二叉树排序

常用的排序算法（主要指面试中）包含两大类，一类是基础比较模型的，也就是排序的过程，是建立在两个数进行对比得出大小的基础上，这样的排序算法又可以分为两类：一类是基于数组的，一类是基于树的；基础数组的比较排序算法主要有：冒泡法，插入法，选择法，归并法，快速排序法；基础树的比较排序算法主要有：堆排序和二叉树排序；基于非比较模型的排序，主要有桶排序和位图排序（个人认为这两个属于同一思路的两个极端）。

5. 由输入的四则算术表达式字符串，动态生成算术表达式所对应的二叉树，通过二叉树遍历求值并输出。 【实验

可以看看我的博客二叉树实现：http://blog.csdn.net/acvcla/article/details/28137067，栈实现：http://blog.csdn.net/acvcla/article/details/41732447，这个和你说的一样，满意请采纳，不懂的可以给我发邮件讨论

6. 设计一个四则运算的程序

给你说个思路，代码自己写吧，不太简单呢。
说白了，就是一个堆栈。
有两个栈，一个是操作数，一个是操作符。每次读到操作符，就跟栈顶的操作符比较优先级（当然是自己先写好的），然是确定是否出栈。如果出栈，之后再和下一个比较。为了使第一个进栈的字符有所比较，通常先压入一个“#”。
在操作符出栈时，同时弹出两个操作数，并将结果压回去。

7. 编写一个程序，实现二叉树的各种基本运算

//文件名:exp7-1.cpp
#include 
typedef char ElemType;
typedef struct node
{
 ElemType data;    //数据元素
 struct node *lchild;  //指向左孩子
 struct node *rchild;  //指向右孩子
} BTNode;
extern void CreateBTNode(BTNode *&b,char *str);
extern BTNode *FindNode(BTNode *b,ElemType x);
extern BTNode *LchildNode(BTNode *p);
extern BTNode *RchildNode(BTNode *p);
extern int BTNodeDepth(BTNode *b);
extern void DispBTNode(BTNode *b);
extern int BTWidth(BTNode *b);
extern int Nodes(BTNode *b);
extern int LeafNodes(BTNode *b);
extern void DestroyBTNode(BTNode *&b);
void main()
{ BTNode *b,*p,*lp,*rp;;
 CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
 printf("二叉树的基本运算如下:\n");
 printf("  (1)输出二叉树:");DispBTNode(b);printf("\n");
 printf("  (2)H节点:");
 p=FindNode(b,'H');
 if (p!=NULL)
 { lp=LchildNode(p);
  if (lp!=NULL) 
   printf("左孩子为%c ",lp->data);
  else
   printf("无左孩子 ");
  rp=RchildNode(p);
  if (rp!=NULL)
   printf("右孩子为%c",rp->data);
  else
   printf("无右孩子 ");
 }
 printf("\n");
 printf("  (3)二叉树b的深度:%d\n",BTNodeDepth(b));
 printf("  (4)二叉树b的宽度:%d\n",BTWidth(b));
 printf("  (5)二叉树b的节点个数:%d\n",Nodes(b));
 printf("  (6)二叉树b的叶子节点个数:%d\n",LeafNodes(b));
 printf("  (7)释放二叉树b\n");
 DestroyBTNode(b);
}

8. python编写欧式二叉树的问题

所以我就遇到了一下几个问题：
1、该怎么把二叉树各个节点连起来？
2、怎么定义内部数据成员？
3、如何实例化左右孩子？

在网上也没找到比较简单比较通用的Python二叉树类实现，所以我花了点时间自己写一个。
[python] view plain copy 在CODE上查看代码片派生到我的代码片
class Tree:  
def __init__(self, val = '#', left = None, right = None):  
self.val = val  
self.left = left  
self.right = right  

#前序构建二叉树  
def FrontBuildTree(self):  
temp = input('Please Input: ')  
node = Tree(temp)  
if(temp != '#'):  
node.left = self.FrontBuildTree()  
node.right = self.FrontBuildTree()  
return node#因为没有引用也没有指针，所以就把新的节点给返回回去  

#前序遍历二叉树  
def VisitNode(self):  
print(self.val)  
if(self.val != '#'):  
self.left.VisitNode()  
self.right.VisitNode()  

if __name__ == '__main__':  
root = Tree()  
root = root.FrontBuildTree()  
root.VisitNode()