此文将讲述如何用python实战解决二叉树实验

前面已经讲述了python语言的基本用法,现在让我们实战一下具体明确python的用法

点击我进入python速成笔记

先看一下最终效果图:

首先我们要定义二叉树结点的一个类,在python中定义二叉树结点代码如下:

#二叉链表
class BiTree:
def __init__(self, elementType=None, lchild=None, rchild=None):
self.elementType = elementType
self.lchild = lchild
self.rchild = rchild

其次初始化二叉树头结点的代码如下:

#初始化二叉树新建头结点
def initTree(s):
temp=BiTree()
ptree=BiTree("A",temp,temp)
if s[2]==0:
ptree.lchild=None
if s[4]==0:
ptree.rchild=None
return ptree,temp

二叉树中经常需要访问子节点,那么子节点的代码:

#寻找下一个结点
def getNext(tree,temp):
if(tree.lchild ==temp ):
return tree
if (tree.lchild!=None):
if(getNext(tree.lchild,temp)!=None):
return getNext(tree.lchild,temp)
if (tree.rchild==temp):
return tree
if(tree.rchild !=None):
if (getNext(tree.rchild,temp) != None):
return getNext(tree.rchild,temp)
return None

有了头结点也能找到子节点,那么绘图二叉树的代码如下:

绘图需要传入图形窗口对象,根节点,初始根节点x,y坐标以及深度1

#画出二叉树图
def drawroot(graph,root,x,y,deep):
# 画椭圆
oval = Oval(Point(x-20, y-20), Point(x+20, y+20))
oval.setFill('blue') # 填充颜色
oval.draw(graph)
# 显示文字
message = Text(Point(x, y), root.elementType)
message.draw(graph)
if(root.lchild!=None):
# 画线
line = Line(Point(x - 10, y + 10), Point(x - 30*deep, y + 60))
line.draw(graph)
drawroot(graph,root.lchild,x-30*deep,y+60,deep-1)
if(root.rchild!=None):
# 画线
line = Line(Point(x+10, y + 10), Point(x + 30*deep, y + 60))
line.draw(graph)
drawroot(graph, root.rchild, x + 30*deep, y + 60,deep-1)

如何快速生成二叉树需要动用文件,根据文件链接子树代码:

读入根节点和一个临时结点,根节点名字和是否有左右子树开始链接

#根据文件建立二叉链表
def getTree(tree,temp,name,left,right):
child=BiTree(name,temp,temp)
if(not left):
child.lchild=None
if(not right):
child.rchild=None
if(tree.lchild==temp):
tree.lchild=child
elif(tree.rchild==temp):
tree.rchild=child

具体完整读取代码完全链接子树代码如下:

input = open('bt31.txt', 'r')
s = []
try:
for line in input:
s.append(line)
finally:
input.close()
ptree, temp = initTree(s[0])
for i in range(len(s)):
if i != 0:
getTree(getNext(ptree, temp), temp, s[i][0], eval(s[i][2]), eval(s[i][4]))

然后生成图形窗口绘制上面二叉树代码为:

gragh = GraphWin('CSSA', 1200, 700)
drawroot(gragh, ptree, 500, 20, 4)

效果如下:

以上便是二叉树生成的前提操作,后面代码即为数据结构实验五二叉树1-10题必做题源代码以及12,13,15选做题源码:



#三种二叉遍历

def DLR(tree):
order=[]
if(tree!=None):
order.append(tree.elementType)
if(tree.lchild!=None):
order=order+DLR(tree.lchild)
if(tree.rchild!=None):
order=order+DLR(tree.rchild)
return order
def LDR(tree):
order=[]
if (tree != None):
if (tree.lchild != None):
order = order + LDR(tree.lchild)
order.append(tree.elementType)
if (tree.rchild != None):
order = order + LDR(tree.rchild)
return order
def LRD(tree):
order=[]
if (tree != None):
if (tree.lchild != None):
order = order + LRD(tree.lchild)
if (tree.rchild != None):
order = order + LRD(tree.rchild)
order.append(tree.elementType)
return order #打印题目一信息
def exp1(gragh,ptree):
str=""
str += "先序遍历:"
for i in range(len(DLR(ptree))):
str+=DLR(ptree)[i]
str +="\n"
str += "中序遍历:"
for i in range(len(LDR(ptree))):
str +=LDR(ptree)[i]
str +="\n"
str += "后序遍历:"
for i in range(len(LRD(ptree))):
str +=LRD(ptree)[i]
str +="\n"
message = Text(Point(200, 400), "1.打印出二叉树的三种遍历序\n"+str)
message.draw(gragh) #遍历结点层次
def DLRDeep(tree,deep):
order=""
if(tree!=None):
order=order+tree.elementType+" "+repr(deep)+"\n"
if(tree.lchild!=None):
order=order+DLRDeep(tree.lchild,deep+1)
if(tree.rchild!=None):
order=order+DLRDeep(tree.rchild,deep+1)
return order
def exp2(gragh,ptree):
str=DLRDeep(ptree,1)
message = Text(Point(1000, 300), "2.输出各结点的层次\n"+str)
message.draw(gragh) #查找树的高度 def height(tree):
h=0
if(tree!=None):
left=height(tree.lchild)
right=height(tree.rchild)
if(left>right):
h=left+1
else :
h=right+1
return h
def exp3(gragh,ptree):
str="3.该二叉树高度为"+repr(height(ptree))
message = Text(Point(500, 350), str)
message.draw(gragh) #查询结点数量 def getnum(tree):
num=0
if(tree!=None):
num=num+1
num+=getnum(tree.lchild)
num+=getnum(tree.rchild)
return num
def exp4(gragh,ptree):
str="4.该二叉树结点数为"+repr(getnum(ptree))
message = Text(Point(500, 400), str)
message.draw(gragh) #查询叶子结点数量 def getleaf(tree):
num=0
if(tree!=None):
num+=getleaf(tree.lchild)
num+=getleaf(tree.rchild)
if(tree.lchild==None and tree.rchild==None):
return 1
return num
def exp5(gragh,ptree):
str="5.该二叉树叶子结点数为"+repr(getleaf(ptree))
message = Text(Point(500, 450), str)
message.draw(gragh) #查询两个度的结点数量 def getTwo(tree):
num=0
if(tree!=None):
num+=getTwo(tree.lchild)
num+=getTwo(tree.rchild)
if(tree.lchild!=None and tree.rchild!=None):
num+=1
return num
def exp6(gragh,ptree):
str="6.该二叉树有两个度的结点有:"+repr(getTwo(ptree))
message = Text(Point(500, 500), str)
message.draw(gragh) #查询父亲结点,兄弟结点,子节点
def findFather(tree,name):
if(tree!=None):
if(tree.lchild!=None and tree.lchild.elementType==name):
return tree
if(tree.rchild!=None and tree.rchild.elementType==name):
return tree
if findFather(tree.rchild,name)!=None:
return findFather(tree.rchild,name)
if findFather(tree.lchild,name)!=None:
return findFather(tree.lchild,name)
return None
def info(tree,name):
father=findFather(tree,name)
if(father.lchild!=None and father.lchild.elementType==name):
brother=father.rchild
son1=father.lchild.lchild
son2=father.lchild.rchild
else :
brother=father.lchild
son1=father.rchild.lchild
son2=father.rchild.rchild
return father,brother,son1,son2
def exp7(gragh ,tree,name):
str=""
father,brother,son1,son2=info(tree,name)
if(father==None):
str+="8.父节点不存在"+"\n"
else:
str+="8.父节点为:"+repr(father.elementType)+"\n"
if(brother==None):
str+="兄弟结点不存在"+"\n"
else:
str+="兄弟结点为:"+repr(brother.elementType)+"\n"
if(son1==None):
str+="左子结点不存在"+"\n"
else:
str+="左子结点为:"+repr(son1.elementType)+"\n"
if (son1 == None):
str += "右子结点不存在"+"\n"
else:
str+="右子结点为:"+repr(son2.elementType)+"\n"
message = Text(Point(400, 550), str)
message.draw(gragh) #查询指定结点深度
def getdeep(tree,name,deep): #EXP8
if (tree != None):
if (tree.elementType==name):
return deep
deepleft=getdeep(tree.lchild,name,deep+1)
deepright=getdeep(tree.rchild,name,deep+1)
if(deepleft!=0):
return deepleft
if(deepright!=0):
return deepright
return 0
def exp8(gragh,tree,name):
deep=getdeep(tree,name,1)
if(deep==0):
message = Text(Point(400, 500), "7.本结点不存在")
message.draw(gragh)
return 0
else:
message = Text(Point(400, 500), "7.本结点:"+repr(name)+"深度为"+repr(deep))
message.draw(gragh)
return 1
#顺序存储变为二叉链表存储
def seqToNode(s,tree,i): if(tree!=None):
if(i*2>len(s)):
tree.lchild=None
elif (s[i*2]==None) :
tree.lchild=None
else:
temp = BiTree(s[i*2])
tree.lchild=temp
if(i*2+1>len(s)):
tree.rchild=None
elif (s[i*2+1]==None):
tree.rchild=None
else:
temp = BiTree(s[i*2 + 1])
tree.rchild=temp
seqToNode(s,tree.lchild,i*2)
seqToNode(s,tree.rchild,i*2+1) #交换左右二叉树 def change(tree):# EXP10
if(tree!=None):
temp=tree.lchild
tree.lchild=tree.rchild
tree.rchild=temp
if(tree.lchild!=None):
change(tree.lchild)
if(tree.rchild!=None):
change(tree.rchild) #找所有结点的路径
def road(s,tree,all):
if(tree.rchild==None and tree.lchild==None):
all.append(repr(tree.elementType))
all.append("到根节点的路径为"+reverse1(s)+"A"+"\n")
if(tree.lchild!=None):
road(s+tree.lchild.elementType,tree.lchild,all)
if(tree.rchild!=None):
road(s+(tree.rchild.elementType),tree.rchild,all)
def exp12(all,gragh,ptree):
str=""
road(str, ptree, all)
for i in range (len(all)):
str+=all[i] message = Text(Point(150, 450), "12.从每个叶子结点到根结点的路径:\n"+str)
message.draw(gragh) #按层次打印结点
def exp13(gragh,tree):
que=Queue()
que.enqueue(tree)
str="13.结点按层次打印结果为\n"
while(not que.isEmpty()):
if(que.getTop().lchild!=None):
que.enqueue(que.getTop().lchild)
if(que.getTop().rchild!=None):
que.enqueue(que.getTop().rchild)
str+=repr(que.getTop().elementType)
que.outqueue()
message = Text(Point(600, 400), str)
message.draw(gragh) #查找最长路径
def maxpath(temp,tree,path,deep):
if (tree.rchild == None and tree.lchild == None):
return temp,deep
deep1,deep2=0,0
if (tree.lchild != None):
path1,deep1=maxpath(temp + tree.lchild.elementType, tree.lchild, path,deep+1)
if (tree.rchild != None):
path2,deep2=maxpath(temp + (tree.rchild.elementType), tree.rchild, path,deep+1)
if(deep1>deep2):
return path1,deep1
else :
return path2,deep2
def exp15(gragh,tree):
temp=""
path=""
path,deep=maxpath(temp,tree,path,1)
message = Text(Point(600, 500), "15.该二叉树最长路径为:\nA"+path+"\n长度为"+repr(deep))
message.draw(gragh)

值得注意的是13题需要用到队列,需要提前写好队列的代码如下:

class Queue:
"""模拟队列""" def __init__(self):
self.items = [] def isEmpty(self):
return self.items == [] def enqueue(self, item):
self.items.insert(0, item) def outqueue(self):
return self.items.pop() def size(self):
return len(self.items)
def getTop(self):
return self.items[self.size()-1]

上述便是代码的全部代码,效果如下

python实战--数据结构二叉树的更多相关文章

  1. python 与数据结构

    在上面的文章中,我写了python中的一些特性,主要是简单为主,主要是因为一些其他复杂的东西可以通过简单的知识演变而来,比如装饰器还可以带参数,可以使用装饰类,在类中不同的方法中调用,不想写的太复杂, ...

  2. [0x00 用Python讲解数据结构与算法] 概览

    自从工作后就没什么时间更新博客了,最近抽空学了点Python,觉得Python真的是很强大呀.想来在大学中没有学好数据结构和算法,自己的意志力一直不够坚定,这次想好好看一本书,认真把基本的数据结构和算 ...

  3. 用Python实现数据结构之二叉搜索树

    二叉搜索树 二叉搜索树是一种特殊的二叉树,它的特点是: 对于任意一个节点p,存储在p的左子树的中的所有节点中的值都小于p中的值 对于任意一个节点p,存储在p的右子树的中的所有节点中的值都大于p中的值 ...

  4. 用Python实现数据结构之优先级队列

    优先级队列 如果我们给每个元素都分配一个数字来标记其优先级,不妨设较小的数字具有较高的优先级,这样我们就可以在一个集合中访问优先级最高的元素并对其进行查找和删除操作了.这样,我们就引入了优先级队列 这 ...

  5. zeromq 学习和python实战

    参考文档: 官网 http://zeromq.org/ http://www.cnblogs.com/rainbowzc/p/3357594.html   原理解读 zeromq只是一层针对socke ...

  6. Python实战:美女图片下载器,海量图片任你下载

    Python应用现在如火如荼,应用范围很广.因其效率高开发迅速的优势,快速进入编程语言排行榜前几名.本系列文章致力于可以全面系统的介绍Python语言开发知识和相关知识总结.希望大家能够快速入门并学习 ...

  7. Python实战:Python爬虫学习教程,获取电影排行榜

    Python应用现在如火如荼,应用范围很广.因其效率高开发迅速的优势,快速进入编程语言排行榜前几名.本系列文章致力于可以全面系统的介绍Python语言开发知识和相关知识总结.希望大家能够快速入门并学习 ...

  8. Python -- 堆数据结构 heapq - I love this game! - 博客频道 - CSDN.NET

    Python -- 堆数据结构 heapq - I love this game! - 博客频道 - CSDN.NET Python -- 堆数据结构 heapq 分类: Python 2012-09 ...

  9. python实现数据结构单链表

    #python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" ...

随机推荐

  1. Cocos 2d-X Lua 游戏添加苹果内购(一) 图文详解准备流程

    事前准备 最近给游戏添加了苹果的内购,这一块的东西也是刚刚做完,总结一下,其实这里不管是游戏还是我们普通的App添加内购这一块的东西都是差不多的,多出来的部分就是我们Lua和OC的交互的部分,以前刚开 ...

  2. (转)MySQL存储过程/存储过程与自定义函数的区别

    转自:http://www.cnblogs.com/caoruiy/p/4486249.html 语法: 创建存储过程: CREATE [definer = {user|current_user}]  ...

  3. (转)[疯狂Java]NIO:Channel的map映射

    原文出自:http://blog.csdn.net/lirx_tech/article/details/51396268 1. 通道映射技术: 1) 其实就是一种快速读写技术,它将通道所连接的数据节点 ...

  4. python核心编程一书笔记之第一篇

    #!/usr/bin/env python# -*- coding:utf-8 -*- #env 是一个命令用来寻找系统中的python解释器.第二条解释使用utf-8编码 在类unix系统中允许py ...

  5. 使用python实现计算器功能

    学习python过程中的作业.实现了+.-.×./.及幂运算,支持括号优先级. 代码为python3.5 import re def formatEquation(string): string = ...

  6. 压缩感知重构算法之子空间追踪(SP)

    SP的提出时间比CoSaMP提出时间稍晚一些,但和压缩采样匹配追踪(CoSaMP)的方法几乎是一样的.SP与CoSaMP主要区别在于“In each iteration, in the SP algo ...

  7. Leetcode题解(32)

    107. Binary Tree Level Order Traversal II 题目 直接代码: /** * Definition for a binary tree node. * struct ...

  8. Windows环境下多线程编程原理与应用读书笔记(6)————临界段及其应用

    <一>临界段 临界段对象通过提供所有线程必须共享的对象来控制线程.只有拥有临界段对象的线程才能够访问保护的资源.在另一个线程可以访问该资源之前,前一线程必须释放临界段对象,一遍新的线程可以 ...

  9. 高性能前端框架React详解

      前  言 React 是一个用于构建[用户界面]的 JAVASCRIPT 库. React主要用于构建UI,很多人认为 React 是 MVC 中的 V(视图). React 起源于 Facebo ...

  10. Here We Go(relians) Again

    Here We Go(relians) Again Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/O ...