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

最新推荐文章于 2019-07-09 15:33:19 发布
最新推荐文章于 2019-07-09 15:33:19 发布
阅读量343 收藏
点赞数
分类专栏： 数据结构 学习笔记 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
'''
随遇而安_小强
关注
专栏目录
Python实现栈、队列和双端队列
MrLittleDog的博客
07-07 1077
文章目录栈队列双端队列 栈 栈（stack）是一种容器，它的特点在于只允许在容器的一端（称为栈顶指标，即top）进行加入数据（push）和输出数据（pop）的运算，即按照后进先出（LIFO，Last In First Out）的原理运作。 栈可以用顺序表实现，也可以用链表实现。顺序表或链表决定了数据如何存放，栈决定了数据如何操作。 Python中的列表（List）就相当于顺序表，现在我们采用Lis...
Python数据结构2-----队列和堆
weixin_33998125的博客
04-27 123
一、线性结构：栈、队列、双端队列、列表 二、非线性结构：树、图、堆 【算法中看堆是非线性的，因为其相当于完全二叉树，但堆的存储元素是采用线性的顺序表数组来实现的】 三、队列： 1、队列类型：FIFO、LIFO、双端队列、循环队列 FIFO：先进先出 LIFO：后进先出（相当于栈） 双端队列：LIFO和FIFO的结合，就是可从队首和队尾添加和删除元素。 循环队列：队首和队尾相连（可以...
python中的集合、堆和双端队列
Joey Chow
03-01 256
文章目录集合、堆和双端队列集合（set）堆（heap）双端队列 集合、堆和双端队列 集合（set） 集合是一种元素排列顺序不确定的元素集。集合是可变的，因此集合不能作为dict中的键，并且由于集合智能包括不可变的值，因此集合中不能包括其他的集合。 集合中的常用函数 #生成一个集合 a = set(range(10)) print(a) #集合中常用的方法 #union 表示求两个集合的并集，|也...
栈，队列，图，二叉树-排序-python
fripSideII的博客
01-30 228
栈 class PyStack: def __init__(self, size = 20): self.stack = [] self.size = size self.top = -1 #栈顶位置 def setSize(self, size): self.size = size ...
用Python实现stack和queue
phthon1997的博客
10-29 393
栈的实现 class Stack(object): """栈""" def __init__(self): self.__list = [] def push(self, item): """添加一个新的元素item到栈顶""&quo
Python中的栈，队列和双端队列
zgb123e的博客
07-09 234
1，什么是抽象数据类型 定义：抽象数据类型(Abstract Data Type 简称ADT)是指一个数学模型以及定义在此数学模型上的一组操作。抽象数据类型需要通过固有数据类型(高级编程语言中已实现的数据类型)来实现。抽象数据类型是与表示无关的数据类型，是一个数据模型及定义在该模型上的一组运算。对一个抽象数据类型进行定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定...
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
Python 实现数据结构中的的栈队列
09-19
在Python中，我们可以使用列表（List）来简单实现栈。以下是一个简单的栈类（Stack）的实现： ```python class Stack(object): def __init__(self): self.__items = [] def push(self, item): self.__items....
双端队列的数据结构与Python实现详解（包含详细的完整的程序和数据）
最新发布
10-10
并通过具体Python编码实现了链表式的双端队列，提供了详尽的操作步骤及其运行实例。 适用人群：对于正在研究数据结构的学习者或是希望提高自己理解和利用高级数据类型能力的学生和技术从业者都颇具价值。 使用场景及...
python数据结构
qq_42015869的博客
04-18 150
#### 栈 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 栈【测试题】
Jibert的博客
06-01 1138
1.删除最外层的括号 信息 有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。 如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符...
数据结构——堆、栈、队列、树、图
hailoneko的博客
07-22 5889
数据结构中的堆栈： 堆可以看成一棵按顺序排列的完全二叉树，根节点可以为大于等于任何子节点（也可以小于等于任意子节点，看具体的排序方法），在存取时没有任何限制，可以随意的访问某一个子节点。 栈或者称为堆栈（stack），可以看成是一些堆起来的盘子，桶状线性数据结构。但是栈是受限制的线性数据结构，只允许先进后出，并且只能在栈顶进行插入删除操作。 内存区的堆栈： 首先了解下内存区：堆区存放程序员...
python数据结构之栈、队列与堆
haiyu94的博客
03-01 1万+
目录 栈与队列的基础知识 使用队列实现栈 (LeetCode 225) 使用栈实现队列 (LeetCode 232) 包含min函数的栈(LeetCode 155) 合法的出栈序列 堆的必备基础知识 数组中的第K大的数 (LeetCode 215) 寻找中位数(LeetCode 295) 1. 栈与队列的基础知识 栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性...
数组、队列、堆、栈、链表、树、图
逍遥的小鱼
11-12 6726
他们都是一种存储数据的方式而已，打个比方，你坐地铁1号线上班和2号线上班，都能上班只是路线不一样，他们都是存储数据的格式，每种数据结构有自己的特点，使用哪种数据格式需要根据具体的需求来选，比如你现在需要有序的存储一组数据而且还要经常的查询数据，那么数组就是最合适的，他有角标可以很容易进行排序和查询！如果有序但是经常增删数据，那么链表就是最合适的，他的增删很快，但是查询差。每种数据结构有各自的适用条...
机器学习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 4406
''' scikit-learn基于AdaBoosts算法提供了两个模型： 1.AdaBoostClassifier用于解决分类问题 2.AdaBoostRegressor用于解决回归问题 ''' from sklearn.ensemble import AdaBoostClassifier AdaBoostClassifier(base_estimator=None, ...
Python实现数据结构实验：栈与队列实战与数制转换
实验一：栈和队列是数据结构课程中的基础部分，主要涉及两种基本线性数据结构：栈和队列。本实验旨在通过实际编程练习，帮助学生深入理解和掌握这两种数据结构的原理、实现方式及其在算法设计中的应用。 1. **数制...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值