Python数据结构之栈、队列及二叉树定义与用法浅析

本文实例讲述了Python数据结构之栈、队列及二叉树定义与用法。分享给大家供大家参考,具体如下:

目前只实现了三种,栈、队列和二叉树,哪天得空继续补吧~

1. 栈

#栈
class Stack:
  def __init__(self,size = 16):
    self.stack = []
    self.size = size
    self.top = -1
  def setSize(self, size):
    self.size = size
  def isEmpty(self):
    if self.top == -1:
      return True
    else:
      return False
  def isFull(self):
    if self.top +1 == self.size:
      return True
    else:
      return False
  def top(self):
    if self.isEmpty():
      raise Exception("StackIsEmpty")
    else:
      return self.stack[self.top]
  def push(self,obj):
    if self.isFull():
      raise Exception("StackOverFlow")
    else:
      self.stack.append(obj)
      self.top +=1
  def pop(self):
    if self.isEmpty():
      raise Exception("StackIsEmpty")
    else:
      self.top -= 1
      return self.stack.pop()
  def show(self):
    print(self.stack)
s = Stack(5)
s.push(1)
s.push(2)
s.push(3)
s.push(4)
s.push(5)
s.show()
s.pop()
s.show()
s.push(6)
s.show()

运行结果:

2. 队列

#队列
class Queue:
  def __init__(self,size = 16):
    self.queue = []
    self.size = size
    self.front = 0
    self.rear = 0
  def isEmpty(self):
    return self.rear == 0
  def isFull(self):
    if (self.front - self.rear +1) == self.size:
      return True
    else:
      return False
  def first(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      return self.queue[self.front]
  def last(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      return self.queue[self.rear]
  def add(self,obj):
    if self.isFull():
      raise Exception("QueueOverFlow")
    else:
      self.queue.append(obj)
      self.rear += 1
  def delete(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      self.rear -=1
      return self.queue.pop(0)
  def show(self):
    print(self.queue)
q = Queue(3)
q.add(1)
q.add(2)
q.show()
q.delete()
q.show()

运行结果:

3. 二叉树

#队列
class Queue:
  def __init__(self,size = 16):
    self.queue = []
    self.size = size
    self.front = 0
    self.rear = 0
  def isEmpty(self):
    return self.rear == 0
  def isFull(self):
    if (self.front - self.rear +1) == self.size:
      return True
    else:
      return False
  def first(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      return self.queue[self.front]
  def last(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      return self.queue[self.rear]
  def add(self,obj):
    if self.isFull():
      raise Exception("QueueOverFlow")
    else:
      self.queue.append(obj)
      self.rear += 1
  def delete(self):
    if self.isEmpty():
      raise Exception("QueueIsEmpty")
    else:
      self.rear -=1
      return self.queue.pop(0)
  def show(self):
    print(self.queue)
#二叉树
class BinaryTreeNode:
  def __init__(self,data,left,right):
    self.left = left
    self.data = data
    self.right = right
class BinaryTree:
  def __init__(self):
    self.root = None
  def makeTree(self,data,left,right):
    self.root = BinaryTreeNode(data,left,right)
    #left.root = right.root = None
  def isEmpty(self):
    if self.root is None:
      return True
    else:
      return False
  def preOrder(self,r):
    if r.root is not None:
      print(r.root.data)
      if r.root.left is not None:
        self.preOrder(r.root.left)
      if r.root.right is not None:
        self.preOrder(r.root.right)
  def inOrder(self,r):
    if r.root is not None:
      if r.root.left is not None:
        self.inOrder(r.root.left)
      print(r.root.data)
      if r.root.right is not None:
        self.inOrder(r.root.right)
  def postOrder(self,r):
    if r.root is not None:
      if r.root.left is not None:
        self.preOrder(r.root.left)
      if r.root.right is not None:
        self.preOrder(r.root.right)
      print(r.root.data)
  def levelOrder(self,a):
    q = Queue()
    r = a
    while r is not None:
      print(r.root.data)
      if r.root.left is not None:
        q.add(r.root.left)
      if r.root.right is not None:
        q.add(r.root.right)
      if q.isEmpty():
        print("empty")
        r = None
      else:
        r = q.delete()
r = BinaryTree()
ra = BinaryTree()
ra.makeTree(2,None,None)
rb = BinaryTree()
rb.makeTree(3,None,None)
r.makeTree(1,ra,rb)
print("前序遍历")
r.preOrder(r)
print("中序遍历")
r.inOrder(r)
print("后序遍历")
r.postOrder(r)
print("层级遍历")
r.levelOrder(r)

运行结果:

后续实现了会慢慢补上~~旧的也会不断改进~~

更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数据结构与算法教程》、《Python加密解密算法与技巧总结》、《Python编码操作技巧总结》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

希望本文所述对大家Python程序设计有所帮助。

(0)

相关推荐

  • Python中的函数式编程:不可变的数据结构

    让我们首先考虑正方形和长方形.如果我们认为在接口方面,忽略了实现细节,方块是否是矩形的子类型? 子类型的定义取决于Liskov代换原理.为了成为一个子类型,它必须能够完成超级类型所做的一切. 如何定义矩形的接口? zope.interface import Interface class IRectangleInterface: get_length: """Squares can do that""" get_width: "&quo

  • python数据结构之线性表的顺序存储结构

    用Python仿照C语言来实现线性表的顺序存储结构,供大家参考,具体内容如下 本文所采用的数据结构模板为 <数据结构教程>C语言版,李春葆.尹为民等著. 该篇所涉及到的是线性表的顺序存储结构. 代码: # !/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'MrHero' class Node(object): """ 线性表的存储结构 和 C 语言中的链式存储结构类似 ""&q

  • python数据结构学习之实现线性表的顺序

    本文实例为大家分享了python实现线性表顺序的具体代码,供大家参考,具体内容如下 线性表 1.抽象数据类型表示(ADT) 类型名称:线性表 数据对象集:线性表是n(>=0)个元素构成的有序序列(a1,a2,-.,an) 操作集: 2.线性表的顺序实现 1.表示方法: 其中100可以自己规定,last代表线性表的长度 # 线性表定义 class Lnode(object): def __init__(self,last): self.data = [None for i in range(100

  • Python数据结构之哈夫曼树定义与使用方法示例

    本文实例讲述了Python数据结构之哈夫曼树定义与使用方法.分享给大家供大家参考,具体如下: HaffMan.py #coding=utf-8 #考虑权值的haff曼树查找效率并非最高,但可以用于编码等使用场景下 class TreeNode: def __init__(self,data): self.data=data self.left=None self.right=None self.parent=None class HaffTree: def __init__(self): sel

  • Python数据结构之图的应用示例

    本文实例讲述了Python数据结构之图的应用.分享给大家供大家参考,具体如下: 一.图的结构 二.代码 # -*- coding:utf-8 -*- #! python3 def searchGraph(graph,start,end): results =[] generatePath(graph,[start],end,results) results.sort(key =lambda x:len(x)) return results def generatePath(graph,path,

  • 详解python的四种内置数据结构

    对于每种编程语言一般都会规定一些容器来保存某些数据,就像java的集合和数组一样python也同样有这样的结构 而对于python他有四个这样的内置容器来存储数据,他们都是python语言的一部分可以直接使用而无需额外的导入 一.列表(list) 列表一种跟java和c中的数据很像的一种数据结构,他都是保存一系列相似,且有序元素的集合,不过不同的是列表中的元素可以不是同一种数据类型,且列表的长度是可变的 可以动态的增加可减少这一点则有点像java中的stringBuilder对象,列表中有一点值

  • Python常见数据结构之栈与队列用法示例

    本文实例讲述了Python常见数据结构之栈与队列用法.分享给大家供大家参考,具体如下: Python常见数据结构之-栈 首先,栈是一种数据结构.具有后进先出特性. #栈的实现 class Stack(): def __init__(self,size): self.stack=[] self.size=size self.top=-1 def push(self,content): if self.Full(): print "Stack is Full" else: self.sta

  • Python数据结构之栈、队列及二叉树定义与用法浅析

    本文实例讲述了Python数据结构之栈.队列及二叉树定义与用法.分享给大家供大家参考,具体如下: 目前只实现了三种,栈.队列和二叉树,哪天得空继续补吧~ 1. 栈 #栈 class Stack: def __init__(self,size = 16): self.stack = [] self.size = size self.top = -1 def setSize(self, size): self.size = size def isEmpty(self): if self.top ==

  • python数据结构之栈、队列及双端队列

    目录 1.线性数据结构的定义 2.栈 2.1 栈的定义 2.2 栈的数据类型 2.3 用python实现栈 2.4 栈的应用 3. 队列 3.1 队列的定义 3.2 队列抽象数据类型 3.3 用python实现队列 3.3 队列的应用 4. 双端队列 4.1 双端队列的定义 4.2 双端队列抽象数据类型 4.3 用python实现双端队列 4.3 双端队列的应用 5.链表 5.1 链表定义 5.2 用python实现链表 前文学习: python数据类型: python数据结构:数据类型. py

  • Python数据结构之栈、队列的实现代码分享

    1. 栈 栈(stack)又名堆栈,它是一种运算受限的线性表.其限制是仅允许在表的一端进行插入和删除运算.这一端被称为栈顶,相对地,把另一端称为栈底.向一个栈插入新元素又称作进栈.入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素:从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素. 栈(Stack)是限制插入和删除操作只能在一个位置进行的表,该位置是表的末端,称为栈的顶(top).栈的基本操作有PUSH(入栈)和POP(出栈).栈又被称为LIF

  • Python数据结构之栈详解

    目录 0.学习目标 1.栈的基本概念 1.1栈的基本概念 1.2栈抽象数据类型 1.3栈的应用场景 2.栈的实现 2.1顺序栈的实现 2.1.1栈的初始化 2.2链栈的实现 2.3栈的不同实现对比 3.栈应用 3.1顺序栈的应用 3.2链栈的应用 3.3利用栈基本操作实现复杂算法 0. 学习目标 栈和队列是在程序设计中常见的数据类型,从数据结构的角度来讲,栈和队列也是线性表,是操作受限的线性表,它们的基本操作是线性表操作的子集,但从数据类型的角度来讲,它们与线性表又有着巨大的不同.本节将首先介绍

  • 详解python数据结构之栈stack

    前言 栈(Stack)是一种运算受限的线性表. 按照先进后出(FILO,First In Last Out)的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶.栈只能在一端进行插入和删除操作. 文章内容包含: (1)栈的基本格式 (2)压栈 push_stack (3)出栈 pop_stack (4)取栈顶 peek_stack 一.栈的基本格式 class Stack(): def __init__ (self,size): self.size = size #栈空间大小 self.to

  • Python数据结构之优先级队列queue用法详解

    一.基本用法 Queue类实现了一个基本的先进先出容器.使用put()将元素增加到这个序列的一端,使用get()从另一端删除.具体代码如下所示: import queue q = queue.Queue() for i in range(1, 10): q.put(i) while not q.empty(): print(q.get(), end=" ") 运行之后,效果如下: 这里我们依次添加1到10到队列中,因为先进先出,所以出来的顺序也与添加的顺序相同. 二.LIFO队列 既然

  • python数据结构之递归方法讲解

    目录 1.递归概念 2. 递归三原则 2.1 实现任意进制的数据转换 今天我们来学习python中最为重要的内容之递归,对以往内容感兴趣的同学可以查看下面: python数据类型: python数据结构:数据类型. python的输入输出: python数据结构之输入输出.控制和异常. python面向对象: python数据结构之面向对象. python算法分析: python数据结构算法分析. python数据结构之栈.队列和双端队列 递归是在进行重复性工作中经常考到的问题,非常值得学习.

  • Python编程实现双链表,栈,队列及二叉树的方法示例

    本文实例讲述了Python编程实现双链表,栈,队列及二叉树的方法.分享给大家供大家参考,具体如下: 1.双链表 class Node(object): def __init__(self, value=None): self._prev = None self.data = value self._next = None def __str__(self): return "Node(%s)"%self.data class DoubleLinkedList(object): def

  • Python数据结构与算法之二叉树结构定义与遍历方法详解

    本文实例讲述了Python数据结构与算法之二叉树结构定义与遍历方法.分享给大家供大家参考,具体如下: 先序遍历,中序遍历,后序遍历 ,区别在于三条核心语句的位置 层序遍历  采用队列的遍历操作第一次访问根,在访问根的左孩子,接着访问根的有孩子,然后下一层 自左向右一一访问同层的结点 # 先序遍历 # 访问结点,遍历左子树,如果左子树为空,则遍历右子树, # 如果右子树为空,则向上走到一个可以向右走的结点,继续该过程 preorder(t): if t: print t.value preorde

随机推荐