顺序表、栈（stack）、队列（queue）（Python实现）_基于列表实现stack类、queue类、priorityqueue类python

线性表

一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。线性表是最基本的数据结构

线性表的两种存储方式模型

• 顺序表，将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示。

• 链表，将元素存放在通过链接构造起来的一系列存储块中。
  顺序表的基本形式

顺序表的形式

图a表示的是顺序表的基本形式，数据元素本身连续存储，每个元素所占的存储单元大小固定相同，元素的下标是其逻辑地址，而元素存储的物理地址（实际内存地址）可以通过存储区的起始地址Loc (e0)加上逻辑地址（第i个元素）与存储单元大小（c）的乘积计算而得，即：Loc(ei) = Loc(e0) + c*i
故，访问指定元素时无需从头遍历，通过计算便可获得对应地址，其时间复杂度为O(1)。

如果元素的大小不统一，则须采用图b的元素外置的形式，将实际数据元素另行存储，而顺序表中各单元位置保存对应元素的地址信息（即链接）。图b中的c不再是数据元素的大小，而是存储一个链接地址所需的存储量，这个量通常很小。

顺序表的结构

顺序表由两部分构成

• 表中的元素集合
• 记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储区的容量和当前表中已有的元素个数两项

两种基本实现方式

• 图a为一体式结构，存储表信息的单元与元素存储区以连续的方式安排在一块存储区里。
• 图b为分离式结构，表对象里只保存与整个表有关的信息（即容量和元素个数），实际数据元素存放在另一个独立的元素存储区里，通过链接与基本表对象关联。

元素存储区替换

• 一体式结构由于顺序表信息区与数据区连续存储在一起，所以若想更换数据区，则只能整体搬迁，即整个顺序表对象（指存储顺序表的结构信息的区域）改变了。
• 分离式结构若想更换数据区，只需将表信息区中的数据区链接地址更新即可，而该顺序表对象不变。

元素存储区扩充

动态顺序表，因为其容量可以在使用中动态变化。

扩充的两种策略

• 每次扩充增加固定数目的存储位置，如每次扩充增加10个元素位置，这种策略可称为线性增长。
  特点：节省空间，但是扩充操作频繁，操作次数多。
• 每次扩充容量加倍，如每次扩充增加一倍存储空间。
  特点：减少了扩充操作的执行次数，但可能会浪费空间资源。以空间换时间，推荐的方式。
  顺序表的操作有：增加元素和删除元素。

增加元素

• 尾端加入元素，时间复杂度为O(1)
• 非保序的加入元素（不常见），时间复杂度为O(1)
• 保序的元素加入，时间复杂度为O(n)

删除元素

• 删除表尾元素，时间复杂度为O(1)

• 非保序的元素删除（不常见），时间复杂度为O(1)

• 保序的元素删除，时间复杂度为O(n)

Python中的顺序表

Python中的list和tuple两种类型采用了顺序表的实现技术。
tuple是不可变类型，即不变的顺序表，因此不支持改变其内部状态的任何操作。
list就是一种采用分离式技术实现的动态顺序表。

栈

栈（stack）：只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。
栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。
栈可以用顺序表实现，也可以用链表实现。

coding:utf-8

class Stack():
    """
    栈的操作
    Stack() 创建一个新的空栈
    push(item) 添加一个新的元素item到栈顶
    pop() 弹出栈顶元素
    peek() 返回栈顶元素
    is_empty() 判断栈是否为空
    size() 返回栈的元素个数
    """

    def __init__(self):
        self.__list = []

    def push(self, item):
        """添加一个新的元素item到栈顶"""
        self.__list.append(item)

    def pop(self):
        """弹出栈顶元素"""
        return self.__list.pop()

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是否为空"""
        return self.__list == []

    def size(self):
        """返回栈的元素个数"""
        return len(self.__list)

if __name__ == "__main__":
    s = Stack()
    print(s.is_empty())
    for i in range(6):
        s.push(i)
    print(s.size())
    print(s.is_empty())
    print(s.peek())
    print(s.size())
    print(s.pop())  
    print(s.size())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
'
运行
运行

输出为：

True
6
False
5
6
5
5
1
2
3
4
5
6
7

队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的一端为队尾，允许删除的一端为队头。
性质：先进先出(FIFO)。

队列可以用顺序表或者链表实现。

# coding:utf-8

class Queue():

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

    def __init__(self):
        self.__list = []

    def enqueue(self, item):
        """往队列中添加一个item元素"""
        self.__list.append(item)

    def dequeue(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def is_empty(self):
        """判断一个队列是否为空"""
        return self.__list == []

    def size(self):
        """返回队列的大小"""
        return len(self.__list)

if __name__ == "__main__":
    q = Queue()
    print(q.is_empty())
    for i in range(6):
        q.enqueue(i)
    print(q.size())
    print(q.is_empty())
    print(q.dequeue())
    print(q.size())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
'
运行
运行

输出为：

True
6
False
0
5
1
2
3
4
5

双端队列

双端队列（deque，全名double-ended queue）：限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

# coding：utf-8 
class Deque():

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

    def __init__(self):
        self.__list = []

    def add_front(self, item):
        """往队列中添加一个item元素"""
        self.__list.insert(0, item)

    def add_rear(self, item):
        """往队列中添加一个item元素"""
        self.__list.append(item)

    def remove_front(self):
        """从队列头部删除一个元素"""
        return self.__list.pop(0)

    def remove_rear(self):
        """从队列头部删除一个元素"""
        return self.__list.pop()

    def is_empty(self):
        """判断一个队列是否为空"""
        return self.__list == []

    def size(self):
        """返回队列的大小"""
        return len(self.__list)

if __name__ == "__main__":
    deque = Deque()
    print(deque.is_empty())
    for i in range(6):
        deque.add_front(i)
        deque.add_rear(i)
    print(deque.remove_front())
    for i in range(deque.size()):
        print(deque.remove_rear(), end = " ")
    print()
    print(deque.size())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
'
运行
运行

输出为：

True
5
5 4 3 2 1 0 0 1 2 3 4
0
1
2
3
4