数据结构Python实现之队列，双端队列以及栈

最新推荐文章于 2019-07-09 15:33:19 发布
最新推荐文章于 2019-07-09 15:33:19 发布
阅读量300 收藏
点赞数
分类专栏： 数据结构 学习笔记 python 文章标签： 数据结构 Python实现 队列 双端队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16000815/article/details/81316884
版权

队列：

class Node(object):
    def __init__(self,value=None,next=None):
        self.value = value
        self.next = next

class Linked_List(object):
    def __init__(self,maxsize=None):
        self.maxsize=maxsize
        self.head = Node()
        self.tail = None
        self.length = 0
    def __len__(self):
        return self.length
    def append(self,value):
        if self.maxsize is not None and len(self)>self.maxsize:
            raise Exception('Linked_List is full')
        node = Node(value)
        tailnode = self.tail
        if tailnode is None:
            self.head.next = node
        else:
            tailnode.next = node
        self.tail = node
        self.length += 1
    def appendleft(self,value):
        node = Node(value)
        head_node = self.head.next
        self.head.next = node
        node.next = head_node
        self.length += 1
    def popleft(self):
        if self.length == 0:
            raise Exception('Linked_List is empty')
        head_node = self.head.next
        head_node_next = head_node.next
        self.head.next = head_node_next
        self.length -= 1
        value = head_node.value
        del head_node
        return value
    def iter_node(self):
        cur_node=self.head.next
        while cur_node.next != None:
            yield cur_node
            cur_node =cur_node.next
        yield cur_node
    def __iter__(self):
        for node in self.iter_node():
            yield node.value
class Queue_Empty_Error(Exception):
    pass
class Queue_Full_Error(Exception):
    pass

class Queue(object):
    def __init__(self,maxsize=None):
        self.maxsize = maxsize
        self._item_link_list = Linked_List(maxsize)
    def __len__(self):
        return len(self._item_link_list)
    def push(self,value):#队尾添加元素
        if len(self) >= self.maxsize:
            raise Queue_Full_Error('full queue')
        self._item_link_list.append(value)
    def pop(self):#队列头部删除元素
        if len(self) == 0:
            raise Queue_Empty_Error('empty queue')
        return self._item_link_list.popleft()
    def iter_queue(self):#遍历队列
        for q in self._item_link_list.iter_node():
            yield q.value
    def __iter__(self):#输出队列值
        for q in self._item_link_list:
            yield q

q = Queue(5)#队列的最大长度为5
q.push(1)
q.push(2)
q.push(3)
print('队列的长度：',len(q))
q.push(1)
q.push(2)
print('队列的长度：',len(q))
print('遍历队列：')
j = 1
for i in q:
    print('队列的第%d个值为:%d'%(j,i))
    j += 1

q.pop()
print('队列的长度：',len(q))
q.pop()
print('队列的长度：',len(q))
q.pop()
print('队列的长度：',len(q))
print('遍历队列：')
j = 1
for i in q.iter_queue():
    print('队列的第%d个值为:%d'%(j,i))
    j += 1
'''
输出：
队列的长度： 3
队列的长度： 5
遍历队列：
队列的第1个值为:1
队列的第2个值为:2
队列的第3个值为:3
队列的第4个值为:1
队列的第5个值为:2
队列的长度： 4
队列的长度： 3
队列的长度： 2
遍历队列：
队列的第1个值为:1
队列的第2个值为:2

'''

双端队列：

class Node(object):
    def __init__(self,value=None,prev=None,next=None):
        self.value = value
        self.prev = prev
        self.next = next
class C_Double_Linked_List(object):#循环双端列表
    def __init__(self):
        node = Node()
        node.next = node
        node.prev = node
        self.head = node
        self.length = 0
    def __len__(self):
        return self.length
    def headnode(self):
        return self.head.next
    def tailnode(self):
        return self.head.prev
    def append(self,value):#从末尾添加
        node = Node(value)
        tail_node = self.tailnode()
        tail_node.next = node
        node.prev = tail_node
        node.next = self.head
        self.head.prev = node
        self.length += 1
    def appendleft(self,value):#从开头添加
        node = Node(value)
        if self.head.next is self.head:
            node.next = self.head
            node.prev = self.head
            self.head.next = node
            self.head.prev = node
        else:
            head_node = self.headnode()
            self.head.next = node
            node.prev = self.head
            node.next = head_node
            head_node.prev = node
        self.length += 1
    def remove(self):#从末尾删除
        if self.length == 0:
            return
        else:
            tail_node = self.tailnode()
            tail_node_prev = tail_node.prev
            tail_node_prev.next = self.head
            self.head.prev = tail_node_prev
        self.length -= 1
        return True
    def removeleft(self):#从开头删除
        if self.length == 0:
            return
        else:
            head_node = self.headnode()
            head_node_next = head_node.next
            self.head.next = head_node_next
            head_node_next.prev = self.head
        self.length -= 1
        return True
    def iter_node(self):
        if self.length == 0:
            return
        cur_node = self.head.next
        while cur_node.next is not self.head:
            yield cur_node
            cur_node = cur_node.next
        yield cur_node
    def __iter__(self):
        for node in self.iter_node():
            yield node.value


class Deque(C_Double_Linked_List):#双端队列
    def push(self,value):#从双端队列的末尾添加节点
        self.append(value)
    def pushleft(self,value):#从双端队列的开头添加节点
        self.appendleft(value)
    def pop(self):#从双端队列末尾删除节点
        self.remove()
    def popleft(self):
        self.removeleft()

dq = Deque()
dq.push(1)
dq.push(3)
dq.push(4)
print('双端队列的长度为：',len(dq))
dq.pushleft(7)
dq.pushleft(8)
dq.pushleft(9)
print('双端队列的长度为：',len(dq))
i=1
print('遍历队列：')
for node in dq:
    print('第%d个节点的值:%d'%(i,node))
    i += 1
print('出对操作······')
dq.pop()
dq.pop()
print('双端队列的长度为：',len(dq))
print('遍历队列：')
i=1
for node in dq:
    print('第%d个节点的值:%d'%(i,node))
    i += 1
dq.popleft()
dq.popleft()
print('双端队列的长度为：',len(dq))
print('遍历队列：')
i=1
for node in dq:
    print('第%d个节点的值:%d'%(i,node))
    i += 1
'''
输出：
双端队列的长度为： 3
双端队列的长度为： 6
遍历队列：
第1个节点的值:9
第2个节点的值:8
第3个节点的值:7
第4个节点的值:1
第5个节点的值:3
第6个节点的值:4
出对操作······
双端队列的长度为： 4
遍历队列：
第1个节点的值:9
第2个节点的值:8
第3个节点的值:7
第4个节点的值:1
双端队列的长度为： 2
遍历队列：
第1个节点的值:7
第2个节点的值:1
'''

栈：

class Stack(object):
    def __init__(self):
        self.deque = Deque()
    def push(self,value):
        self.deque.push(value)
    def pop(self):
        self.deque.pop()
    def __len__(self):
        return len(self.deque)
    def __iter__(self):
        for node in self.deque:
            yield node
s = Stack()
s.push(10)
s.push(20)
s.push(30)
s.push(40)
s.push(50)
print('栈的长度为：',len(s))
for i in s:
    print(i)
s.pop()
s.pop()
s.push(100)
s.pop()
s.push(200)
print('栈的长度为：',len(s))
for i in s:
    print(i)

'''
输出：
栈的长度为： 5
10
20
30
40
50
栈的长度为： 4
10
20
30
200
'''
随遇而安_小强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Python实现栈、队列和双端队列
MrLittleDog的博客
07-07 998
文章目录栈队列双端队列 栈 栈（stack）是一种容器，它的特点在于只允许在容器的一端（称为栈顶指标，即top）进行加入数据（push）和输出数据（pop）的运算，即按照后进先出（LIFO，Last In First Out）的原理运作。 栈可以用顺序表实现，也可以用链表实现。顺序表或链表决定了数据如何存放，栈决定了数据如何操作。 Python中的列表（List）就相当于顺序表，现在我们采用Lis...
数据结构之堆栈和队列在python中的实现
Sunshine的博客
01-16 284
1栈和队列是两种基本的数据结构 数据结构之-栈 1.1 栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构，具有后进先出(last in first out，LIFO)的特征，仅能够在栈顶进行操作，，下面这张图展示了栈的工作特点： 仅能够在栈顶进行操作生活中的一个非常贴切的列子，玩羽毛球的同学都会买一筒羽毛球，羽毛球就是这种典型的堆栈结构。 1.2 基本用法 >...
数组、队列、堆、栈、链表、树、图
逍遥的小鱼
11-12 6573
他们都是一种存储数据的方式而已，打个比方，你坐地铁1号线上班和2号线上班，都能上班只是路线不一样，他们都是存储数据的格式，每种数据结构有自己的特点，使用哪种数据格式需要根据具体的需求来选，比如你现在需要有序的存储一组数据而且还要经常的查询数据，那么数组就是最合适的，他有角标可以很容易进行排序和查询！如果有序但是经常增删数据，那么链表就是最合适的，他的增删很快，但是查询差。每种数据结构有各自的适用条...
Python数据结构2-----队列和堆
weixin_33998125的博客
04-27 104
一、线性结构：栈、队列、双端队列、列表 二、非线性结构：树、图、堆 【算法中看堆是非线性的，因为其相当于完全二叉树，但堆的存储元素是采用线性的顺序表数组来实现的】 三、队列： 1、队列类型：FIFO、LIFO、双端队列、循环队列 FIFO：先进先出 LIFO：后进先出（相当于栈） 双端队列：LIFO和FIFO的结合，就是可从队首和队尾添加和删除元素。 循环队列：队首和队尾相连（可以...
python中的集合、堆和双端队列
Joey Chow
03-01 233
文章目录集合、堆和双端队列集合（set）堆（heap）双端队列 集合、堆和双端队列 集合（set） 集合是一种元素排列顺序不确定的元素集。集合是可变的，因此集合不能作为dict中的键，并且由于集合智能包括不可变的值，因此集合中不能包括其他的集合。 集合中的常用函数 #生成一个集合 a = set(range(10)) print(a) #集合中常用的方法 #union 表示求两个集合的并集，|也...
数据结构——堆、栈、队列、树、图
hailoneko的博客
07-22 5780
数据结构中的堆栈： 堆可以看成一棵按顺序排列的完全二叉树，根节点可以为大于等于任何子节点（也可以小于等于任意子节点，看具体的排序方法），在存取时没有任何限制，可以随意的访问某一个子节点。 栈或者称为堆栈（stack），可以看成是一些堆起来的盘子，桶状线性数据结构。但是栈是受限制的线性数据结构，只允许先进后出，并且只能在栈顶进行插入删除操作。 内存区的堆栈： 首先了解下内存区：堆区存放程序员...
Python中的栈，队列和双端队列
zgb123e的博客
07-09 201
1，什么是抽象数据类型 定义：抽象数据类型(Abstract Data Type 简称ADT)是指一个数学模型以及定义在此数学模型上的一组操作。抽象数据类型需要通过固有数据类型(高级编程语言中已实现的数据类型)来实现。抽象数据类型是与表示无关的数据类型，是一个数据模型及定义在该模型上的一组运算。对一个抽象数据类型进行定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定...
Python 实现数据结构中的的栈队列
09-19
在Python中，我们可以使用列表（List）来简单实现栈。以下是一个简单的栈类（Stack）的实现： ```python class Stack(object): def __init__(self): self.__items = [] def push(self, item): self.__items....
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
Python实现双端队列
12-22
双端队列的数据存储结构可以是顺序表，也可以是链表，本篇文章使用 Python 来分别实现顺序双端队列和链双端队列。 一、实现顺序双端队列 顺序双端队列是使用顺序表存储数据的双端队列，Python 中的列表元组都属于...
（Python3）数据结构–双端队列的原理及实现
12-22
学过数据结构自然是最好的 原理及需要注意的点 双端队列是在队列的基础上进行改进的。关于队列的博客链接：https://blog.csdn.net/sf9898/article/details/104941655 灵魂画手，凑合着看吧 和队列的区别正如名称中...
python数据结构
qq_42015869的博客
04-18 130
#### 栈 class Stack(object): def __init__(self): self.__list = [] def push(self, item): self.__list.append(item) def pop(self): self.__list.pop() def peek(self):...
栈，队列，图，二叉树-排序-python
fripSideII的博客
01-30 213
栈 class PyStack: def __init__(self, size = 20): self.stack = [] self.size = size self.top = -1 #栈顶位置 def setSize(self, size): self.size = size ...
python数据结构之栈、队列与堆
haiyu94的博客
03-01 1万+
目录 栈与队列的基础知识 使用队列实现栈 (LeetCode 225) 使用栈实现队列 (LeetCode 232) 包含min函数的栈(LeetCode 155) 合法的出栈序列 堆的必备基础知识 数组中的第K大的数 (LeetCode 215) 寻找中位数(LeetCode 295) 1. 栈与队列的基础知识 栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性...
用Python实现stack和queue
phthon1997的博客
10-29 370
栈的实现 class Stack(object): """栈""" def __init__(self): self.__list = [] def push(self, item): """添加一个新的元素item到栈顶""&quo
机器学习sklearn中决策树模型参数释义
热门推荐
随遇而安_小强的博客
07-07 2万+
''' scikit-learn中有两类决策树，它们均采用优化的CART决策树算法。 ''' from sklearn.tree import DecisionTreeRegressor ''' 回归决策树 ''' DecisionTreeRegressor(criterion="mse", splitter="best", ...
凸集、凸函数及其充分必要条件
随遇而安_小强的博客
07-22 1万+
凸集的定义： 设集合D⊂RnD⊂RnD \subset {R^n}，若对于任意点x,y∈Dx,y∈Dx,y \in D及实数α∈[0,1]α∈[0,1]\alpha \in \left[ {0,1} \right]，都有αx+(1−α)y∈Dαx+(1−α)y∈D\alpha x + \left( {1 - \alpha } \right)y \in D 则称集合DDD为凸集。 由凸集的定...
详解熵、最大熵、联合熵和条件熵、相对熵以及互信息之间的关系
随遇而安_小强的博客
07-03 1万+
信息量的定义 某事件发生的概率小，则该事件的信息量大。 定义随机变量XXX的概率分布为P(X)P(X)P\left( X \right),XXX的信息量为：h(X)=−log2P(X)h(X)=−log2P(X)h\left( X \right) = - {\log _2}P\left( X \right). 熵 对随机事件按的信息量求期望，得到随机变量XXX的熵： H(X)=−∑...
机器学习库sklearn中集成学习模型参数释义
随遇而安_小强的博客
07-16 4332
''' scikit-learn基于AdaBoosts算法提供了两个模型： 1.AdaBoostClassifier用于解决分类问题 2.AdaBoostRegressor用于解决回归问题 ''' from sklearn.ensemble import AdaBoostClassifier AdaBoostClassifier(base_estimator=None, ...
3. 基本数据结构1
最新发布
08-04
在数据结构的学习中，我们首先要理解抽象数据结构：栈、队列、双端队列、列表，以及利用Python的列表实现这些抽象数据类型。同时，我们需要了解各种基本线性数据结构的实现性能，以及前缀、中缀和后缀表达式的概念，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值