栈与队列

1. 栈

2. 队列

 

 

1. 栈

介绍

栈（stack），有些地方称为堆栈，是一种（线性表）容器，可存入数据元素、访问元素、删除元素，它的特色在于只能容许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（push）和输出数据（pop）的运算。

栈没有了位置概念，保证任什么时候候能够访问、删除的元素都是此前最后存入的那个元素，肯定了一种默认的访问顺序。

因为栈数据结构只容许在一端进行操做，于是按照后进先出（LIFO, Last In First Out）的原理运做。

 栈与线性表的区别

• 栈（和队列）：描述的是数据的操做方式。
• 线性表：描述的是数据的存储方式。

栈结构的实现

栈能够用顺序表实现，也能够用链表实现。

栈的操做

• Stack()：建立一个新的空栈
• push(item)：添加一个新的元素item到栈顶
• pop()：弹出栈顶元素
• peek()：返回栈顶元素
• is_empty()：判断栈是否为空
• size()：返回栈的元素个数

示例

 1 class Stack:
 2     "栈"
 3 
 4     def __init__(self):
 5         self.__list = []
 6 
 7     def push(self, item):
 8         "添加一个新的元素item到栈顶"
 9         self.__list.append(item)  # 时间复杂度为O(1)
10         # self.__list.insert(0, item)  # 时间复杂度为O(n)
11         
12     def pop(self):
13         "弹出栈顶元素"
14         return self.__list.pop()  # 接收列表pop方法的返回值
15         # self.__list.pop(0)  # 时间复杂度为O(n)
16         
17     def peek(self):
18         "返回栈顶元素"
19         if self.__list:
20             return self.__list[-1]
21         else:
22             return 
23         
24     def is_empty(self):
25         "判断栈是否为空"
26         return self.__list == []
27         # return not self.__head
28         
29     def size(self):
30         "返回栈的元素个数"
31         return len(self.__list)
32         
33         
34 if __name__ == "__main__":
35     s = Stack()
36     print(s.is_empty())  # True
37     s.push(1)
38     print(s.is_empty())  # False
39     s.push(2)
40     s.push(3)
41     print(s.peek())  # 3
42     s.push(4)
43     s.push("hello")
44     print(s.pop())  # hello
45     print(s.pop())  # 4
46     print(s.size())  # 3

 

2. 队列

介绍

队列（queue）是只容许在一端进行插入操做，而在另外一端进行删除操做的线性表。

队列是一种先进先出的（FIFO, First In First Out）的线性表。容许插入的一端为队尾，容许删除的一端为队头，队列不容许在中间部位进行操做。

假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样咱们就能够删除时，老是从a1开始，而插入时，老是在队列最后。这也比较符合咱们一般生活中的习惯，排在第一个的优先出列，最后来的固然排在队伍最后。

 队列结构的实现

同栈同样，队列也能够用顺序表或者链表实现。

操做

• Queue()：建立一个空的队列
• enqueue(item)：往队列中添加一个item元素
• dequeue()：从队列头部删除一个元素
• is_empty()：判断一个队列是否为空
• size()：返回队列的大小

示例

 1 class Queue:
 2     "队列"
 3     
 4     def __init__(self):
 5         self.__list = []
 6         
 7     def enqueue(self, item):
 8         "往队列中添加一个item元素"
 9         # 根据具体的使用频率，决定添加/删除元素的方式
10         self.__list.append(item)  # O(1)
11         # self.__list.insert(0, item)  # O(n)
12     
13     def dequeue(self):
14         "从队列头部删除一个元素"
15         return self.__list.pop(0)  # O(n)
16         # return self.__list.pop()  # O(1)
17     
18     def is_empty(self):
19         "判断一个队列是否为空"
20         return self.__list == []
21         # return not self.__list
22         
23     def size(self):
24         "返回队列的大小"
25         return len(self.__list)
26         
27 
28 if __name__ == "__main__":        
29     q = Queue()
30     print(q.is_empty())  # True
31     q.enqueue("hello")
32     print(q.is_empty())  # False
33     q.enqueue(1)
34     q.enqueue(2)
35     q.enqueue(3)
36     print(q.dequeue())  # hello
37     print(q.dequeue())  # 1
38     print(q.size())  # 2

双端列表

双端队列（deque，全名double-ended queue），是一种具备队列和栈的性质的数据结构。

双端队列中的元素能够从两端弹出，其限定插入和删除操做在表的两端进行。双端队列能够在队列任意一端入队和出队。

操做

• Deque()：建立一个空的双端队列
• add_front(item)：从队头加入一个item元素
• add_rear(item)：从队尾加入一个item元素
• remove_front()：从队头删除一个item元素
• remove_rear()：从队尾删除一个item元素
• is_empty()：判断双端队列是否为空
• size()：返回队列的大小

示例

 1 class Deque:
 2     "双端队列"
 3     
 4     def __init__(self):
 5         self.__list = []
 6         
 7     def add_front(self, item):
 8         "往队列头部添加一个item元素"
 9         self.__list.insert(0, item) 
10     
11     def add_rear(self, item):
12         "往队列尾部添加一个item元素"
13         self.__list.append(item)  
14     
15     def remove_front(self):
16         "从队列头部删除一个元素"
17         return self.__list.pop(0) 
18         
19     def remove_rear(self):
20         "从队列尾部删除一个元素"
21         return self.__list.pop()  
22     
23     def is_empty(self):
24         "判断一个队列是否为空"
25         return self.__list == []
26         # return not self.__list
27         
28     def size(self):
29         "返回队列的大小"
30         return len(self.__list)
31         
32 
33 if __name__ == "__main__":        
34     d = Deque()
35     print(d.is_empty())  # True
36     d.add_front(1)
37     d.add_front(2)
38     d.add_rear(3)
39     d.add_rear(4)
40     print(d.is_empty())  # False
41     print(d.size())  # 4
42     print(d.remove_front())  # 2
43     print(d.remove_rear())  # 4
44     print(d.size())  # 2