python使用递归的方式建立二叉树


Posted in Python onJuly 03, 2019

树和图的数据结构,就很有意思啦。

python使用递归的方式建立二叉树

# coding = utf-8

 

 

class BinaryTree:

  def __init__(self, root_obj):

    self.key = root_obj

    self.left_child = None

    self.right_child = None

 

  def insert_left(self, new_node):

    node = BinaryTree(new_node)

    if self.left_child is None:

      self.left_child = node

    else:

      node.left_child = self.left_child

      self.left_child = node

 

  def insert_right(self, new_node):

    node = BinaryTree(new_node)

    if self.right_child is None:

      self.right_child = node

    else:

      node.right_child = self.right_child

      self.right_child = node

 

  def get_right_child(self):

    return self.right_child

 

  def get_left_child(self):

    return self.left_child

 

  def set_root_val(self, obj):

    self.key = obj

 

  def get_root_val(self):

    return self.key

 

 

root = BinaryTree('a')

print(root.get_root_val())

print(root.get_left_child())

root.insert_left('b')

print(root.get_left_child())

print(root.get_left_child().get_root_val())

root.insert_right('c')

print(root.get_right_child())

print(root.get_right_child().get_root_val())

root.get_right_child().set_root_val('hello')

print(root.get_right_child().get_root_val())
C:\Users\Sahara\.virtualenvs\test\Scripts\python.exe C:/Users/Sahara/PycharmProjects/test/python_search.py

a

None

<__main__.BinaryTree object at 0x00000000024139B0>

b

<__main__.BinaryTree object at 0x00000000024139E8>

c

hello

 

Process finished with exit code 0

Python实现二叉树遍历的递归和非递归算法

前序遍历

# -----------前序遍历 ------------
  # 递归算法
  def pre_order_recursive(self, T):
    if T == None:
      return
    print(T.root, end=' ')
    self.pre_order_recursive(T.lchild)
    self.pre_order_recursive(T.rchild)

  # 非递归算法
  def pre_order_non_recursive(self, T):
    """借助栈实现前驱遍历
    """
    if T == None:
      return
    stack = []
    while T or len(stack) > 0:
      if T:
        stack.append(T)
        print(T.root, end=' ')
        T = T.lchild
      else:
        T = stack[-1]
        stack.pop()
        T = T.rchild

中序遍历

# -----------中序遍历 ------------
  # 递归算法
  def mid_order_recursive(self, T):
    if T == None:
      return
    self.mid_order_recursive(T.lchild)
    print(T.root, end=' ')
    self.mid_order_recursive(T.rchild)

  # 非递归算法
  def mid_order_non_recursive(self, T):
    """借助栈实现中序遍历
    """
    if T == None:
      return
    stack = []
    while T or len(stack) > 0:
      if T:
        stack.append(T)
        T = T.lchild
      else:
        T = stack.pop()
        print(T.root, end=' ')
        T = T.rchild

后序遍历

# -----------后序遍历 ------------
  # 递归算法
  def post_order_recursive(self, T):
    if T == None:
      return
    self.post_order_recursive(T.lchild)
    self.post_order_recursive(T.rchild)
    print(T.root, end=' ')

  # 非递归算法
  def post_order_non_recursive(self, T):
    """借助两个栈实现后序遍历
    """
    if T == None:
      return
    stack1 = []
    stack2 = []
    stack1.append(T)
    while stack1:
      node = stack1.pop()
      if node.lchild:
        stack1.append(node.lchild)
      if node.rchild:
        stack1.append(node.rchild)
      stack2.append(node)
    while stack2:
      print(stack2.pop().root, end=' ')
    return

层次遍历

# -----------层次遍历 ------------
  def level_order(self, T):
    """借助队列(其实还是一个栈)实现层次遍历
    """
    if T == None:
      return
    stack = []
    stack.append(T)
    while stack:
      node = stack.pop(0) # 实现先进先出
      print(node.root, end=' ')
      if node.lchild:
        stack.append(node.lchild)
      if node.rchild:
        stack.append(node.rchild)

完整代码

class NodeTree:
  def __init__(self, root=None, lchild=None, rchild=None):
    """创建二叉树
    Argument:
      lchild: BinTree
        左子树
      rchild: BinTree
        右子树

    Return:
      Tree
    """
    self.root = root
    self.lchild = lchild
    self.rchild = rchild


class BinTree:

  # -----------前序遍历 ------------
  # 递归算法
  def pre_order_recursive(self, T):
    if T == None:
      return
    print(T.root, end=' ')
    self.pre_order_recursive(T.lchild)
    self.pre_order_recursive(T.rchild)

  # 非递归算法
  def pre_order_non_recursive(self, T):
    """借助栈实现前驱遍历
    """
    if T == None:
      return
    stack = []
    while T or len(stack) > 0:
      if T:
        stack.append(T)
        print(T.root, end=' ')
        T = T.lchild
      else:
        T = stack[-1]
        stack.pop()
        T = T.rchild

  # -----------中序遍历 ------------
  # 递归算法
  def mid_order_recursive(self, T):
    if T == None:
      return
    self.mid_order_recursive(T.lchild)
    print(T.root, end=' ')
    self.mid_order_recursive(T.rchild)

  # 非递归算法
  def mid_order_non_recursive(self, T):
    """借助栈实现中序遍历
    """
    if T == None:
      return
    stack = []
    while T or len(stack) > 0:
      if T:
        stack.append(T)
        T = T.lchild
      else:
        T = stack.pop()
        print(T.root, end=' ')
        T = T.rchild

  # -----------后序遍历 ------------
  # 递归算法
  def post_order_recursive(self, T):
    if T == None:
      return
    self.post_order_recursive(T.lchild)
    self.post_order_recursive(T.rchild)
    print(T.root, end=' ')

  # 非递归算法
  def post_order_non_recursive(self, T):
    """借助两个栈实现后序遍历
    """
    if T == None:
      return
    stack1 = []
    stack2 = []
    stack1.append(T)
    while stack1:
      node = stack1.pop()
      if node.lchild:
        stack1.append(node.lchild)
      if node.rchild:
        stack1.append(node.rchild)
      stack2.append(node)
    while stack2:
      print(stack2.pop().root, end=' ')
    return

  # -----------层次遍历 ------------
  def level_order(self, T):
    """借助队列(其实还是一个栈)实现层次遍历
    """
    if T == None:
      return
    stack = []
    stack.append(T)
    while stack:
      node = stack.pop(0) # 实现先进先出
      print(node.root, end=' ')
      if node.lchild:
        stack.append(node.lchild)
      if node.rchild:
        stack.append(node.rchild)

  # ----------- 前序遍历序列、中序遍历序列 —> 重构二叉树 ------------
  def tree_by_pre_mid(self, pre, mid):
    if len(pre) != len(mid) or len(pre) == 0 or len(mid) == 0:
      return
    T = NodeTree(pre[0])
    index = mid.index(pre[0])
    T.lchild = self.tree_by_pre_mid(pre[1:index + 1], mid[:index])
    T.rchild = self.tree_by_pre_mid(pre[index + 1:], mid[index + 1:])
    return T

  # ----------- 后序遍历序列、中序遍历序列 —> 重构二叉树 ------------
  def tree_by_post_mid(self, post, mid):
    if len(post) != len(mid) or len(post) == 0 or len(mid) == 0:
      return
    T = NodeTree(post[-1])
    index = mid.index(post[-1])
    T.lchild = self.tree_by_post_mid(post[:index], mid[:index])
    T.rchild = self.tree_by_post_mid(post[index:-1], mid[index + 1:])
    return T


if __name__ == '__main__':
  # ----------- 测试:前序、中序、后序、层次遍历 -----------
  # 创建二叉树
  nodeTree = NodeTree(1,
            lchild=NodeTree(2,
                    lchild=NodeTree(4,
                            rchild=NodeTree(7))),
            rchild=NodeTree(3,
                    lchild=NodeTree(5),
                    rchild=NodeTree(6)))
  T = BinTree()
  print('前序遍历递归\t')
  T.pre_order_recursive(nodeTree) # 前序遍历-递归
  print('\n')
  print('前序遍历非递归\t')
  T.pre_order_non_recursive(nodeTree) # 前序遍历-非递归
  print('\n')
  print('中序遍历递归\t')
  T.mid_order_recursive(nodeTree) # 中序遍历-递归
  print('\n')
  print('中序遍历非递归\t')
  T.mid_order_non_recursive(nodeTree) # 中序遍历-非递归
  print('\n')
  print('后序遍历递归\t')
  T.post_order_recursive(nodeTree) # 后序遍历-递归
  print('\n')
  print('后序遍历非递归\t')
  T.post_order_non_recursive(nodeTree) # 后序遍历-非递归
  print('\n')
  print('层次遍历\t')
  T.level_order(nodeTree) # 层次遍历
  print('\n')

  print('==========================================================================')

  # ----------- 测试:由遍历序列构造二叉树 -----------
  T = BinTree()
  pre = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
  mid = ['B', 'C', 'A', 'E', 'D', 'G', 'H', 'F', 'I']
  post = ['C', 'B', 'E', 'H', 'G', 'I', 'F', 'D', 'A']

  newT_pre_mid = T.tree_by_pre_mid(pre, mid) # 由前序序列、中序序列构造二叉树
  T.post_order_recursive(newT_pre_mid) # 获取后序序列
  print('\n')

  newT_post_mid = T.tree_by_post_mid(post, mid) # 由后序序列、中序序列构造二叉树
  T.pre_order_recursive(newT_post_mid) # 获取前序序列

运行结果

前序遍历递归 
1 2 4 7 3 5 6

前序遍历非递归 
1 2 4 7 3 5 6

中序遍历递归 
4 7 2 1 5 3 6

中序遍历非递归 
4 7 2 1 5 3 6

后序遍历递归 
7 4 2 5 6 3 1

后序遍历非递归 
7 4 2 5 6 3 1

层次遍历 
1 2 3 4 5 6 7

==========================================================================
C B E H G I F D A

A B C D E F G H I

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持三水点靠木。

Python 相关文章推荐
python socket网络编程步骤详解(socket套接字使用)
Dec 06 Python
Python对象类型及其运算方法(详解)
Jul 05 Python
Python实现的快速排序算法详解
Aug 01 Python
Python DataFrame 设置输出不显示index(索引)值的方法
Jun 07 Python
使用anaconda的pip安装第三方python包的操作步骤
Jun 11 Python
pycharm+PyQt5+python最新开发环境配置(踩坑)
Feb 11 Python
提升Python程序性能的7个习惯
Apr 14 Python
django 微信网页授权认证api的步骤详解
Jul 30 Python
ORM Django 终端打印 SQL 语句实现解析
Aug 09 Python
对Python中一维向量和一维向量转置相乘的方法详解
Aug 26 Python
Python 实现自动完成A4标签排版打印功能
Apr 09 Python
Python将QQ聊天记录生成词云的示例代码
Feb 10 Python
python挖矿算力测试程序详解
Jul 03 #Python
如何用Python做一个微信机器人自动拉群
Jul 03 #Python
Python中的正则表达式与JSON数据交换格式
Jul 03 #Python
python实现共轭梯度法
Jul 03 #Python
python实现微信自动回复及批量添加好友功能
Jul 03 #Python
Python 中Django安装和使用教程详解
Jul 03 #Python
利用python求积分的实例
Jul 03 #Python
You might like
PHP开发大型项目的一点经验
2006/10/09 PHP
javascript一些不错的函数脚本代码
2008/09/10 Javascript
ie8本地图片上传预览示例代码
2014/01/12 Javascript
JavaScript中自定义事件用法分析
2014/12/23 Javascript
javascript结合canvas实现图片旋转效果
2015/05/03 Javascript
50 个 jQuery 插件可将你的网站带到另外一个高度
2016/04/26 Javascript
Bootstrap框架的学习教程详解(二)
2016/10/18 Javascript
JS中用try catch对代码运行的性能影响分析
2016/12/26 Javascript
angular分页指令操作
2017/01/09 Javascript
jQuery插件FusionCharts实现的2D饼状图效果【附demo源码下载】
2017/03/03 Javascript
Node+OCR实现图像文字识别功能
2018/11/26 Javascript
详解如何理解vue的key属性
2019/04/14 Javascript
angularjs1.X 重构controller 的方法小结
2019/08/15 Javascript
Vue基础配置讲解
2019/11/29 Javascript
Openlayers实现距离面积测量
2020/09/28 Javascript
[54:27]TNC vs Serenity 2018国际邀请赛小组赛BO2 第一场 8.18
2018/08/19 DOTA
[51:32]Optic vs Serenity 2018国际邀请赛淘汰赛BO3 第一场 8.22
2018/08/23 DOTA
Python构造自定义方法来美化字典结构输出的示例
2016/06/16 Python
使用pandas模块读取csv文件和excel表格,并用matplotlib画图的方法
2018/06/22 Python
python elasticsearch环境搭建详解
2019/09/02 Python
python pygame实现滚动横版射击游戏城市之战
2019/11/25 Python
canvas像素画板的实现代码
2018/11/21 HTML / CSS
Html5 Canvas 实现一个“刮刮乐”游戏
2019/09/05 HTML / CSS
关于老式浏览器兼容HTML5和CSS3的问题
2016/06/01 HTML / CSS
国际知名设计师时装商店:Coggles
2016/09/05 全球购物
丝芙兰中国官方商城:SEPHORA中国
2018/01/10 全球购物
美团网旗下网上订餐平台:美团外卖
2020/03/05 全球购物
西安众合通用.net笔试题
2013/03/18 面试题
电子商务专业个人的自我评价
2013/12/19 职场文书
县委常委班子专题民主生活会查摆问题及整改措施
2014/09/27 职场文书
公司领导班子群众路线四风问题对照检查材料
2014/10/02 职场文书
微信搭讪开场白
2015/05/28 职场文书
公司车辆管理制度
2015/08/04 职场文书
导游词之青城山景区
2019/09/27 职场文书
解决Vue+SpringBoot+Shiro跨域问题
2021/06/09 Vue.js
python人工智能human learn绘图可创建机器学习模型
2021/11/23 Python