顺序表、栈与队列

一、顺序表引入

1什么是线性表

1 在程序中，经常需要将一组数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。
2 一组数据中包含的元素个数可能发生变化（增加或删除元素）。
3 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中
的某种有意义的信息，或者表示数据之间的某种关系。
4 这样的一组序列元素的组织形式，我们可以将其抽象为线性表。
5 一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。
6 线性表是最基本的数据结构之一，在实际程序中应用非常广泛，它还经常被用作更复杂的数据结构的实现基础。

2 什么是顺序表

1 根据线性表的实际存储方式，分为两种实现模型：
2 顺序表，将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示。
3 链表，将元素存放在通过链接构造起来的一系列存储块中。

二、顺序表的基本形式

基本存储形式

元素外置的顺序表

三 顺序表的结构与实现

1 顺序表的结构

1 一个顺序表的完整信息包括两部分
2 一部分是表中的元素集合
3 另一部分是为实现正确操作而需记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储区的容量和当前表中已有的元素个数两项。

   　　　　

2 顺序表的两种基本实现方式

l 一体式存储，类似于数组，不可变长度

　　　　 

l 分离式存储，类似于列表，可变长度

 

3 扩容的两种策略

1 每次扩充增加固定数目的存储位置，如每次扩充增加10个元素位置，这种策略可称为线性增长。
2 每次扩充容量加倍，如每次扩充增加一倍存储空间。

四、顺序表的操作

1 插入元素

l 为顺序表插入新元素111的三种方式时间复杂度为多少？

　　　　　　a：O(1)
　　　　　　b：O(1)
　　　　　　c：O(n)

 2  删除元素

l 删除顺序表中元素的三种方式时间复杂度为多少？

　　　　　　a：O(1)
　　　　　　b：O(1)
　　　　　　c：O(n)

 五：Python中的顺序表

1 Python中的list和tuple两种类型采用了顺序表的实现技术，具有前面讨论的顺序表的性质
2 tuple是不可变类型，即不变的顺序表，因此不支持改变其内部状态的任何操作，而其他方面，则与list的性质类似

1. list的基本实现技术

1 Python标准类型list就是一种元素个数可变的线性表，可以加入和删除元素，并在各种操作中维持已有元素的顺序（即保序），而且还具有以下行为特征：
        1）基于下标（位置）的高效元素访问和更新，时间复杂度应该是O(1)，为满足该特征，应该采用顺序表技术，
　　　　表中元素保存在一块连续的存储区中。
        2）允许任意加入元素，而且在不断加入元素的过程中，表对象的标识（函数id得到的值）不变，为满足该特征，
　　　　就必须能更换元素存储区，并且为保证更换存储区时list对象的标识id不变，只能采用分离式实现技术。
2 在Python的官方实现中，list就是一种采用分离式技术实现的动态顺序表。这就是为什么用list.append(x)或list.insert(len(list), x)，
即尾部插入，比在指定位置插入元素效率高。
3 在Python的官方实现中，list实现采用了如下的策略：
       1）在建立空表（或者很小的表）时，系统分配一块能容纳8个元素的存储区。
       2）在执行插入操作（insert或append）时，如果元素存储区满就换一块4倍大的存储区。
       3）但如果此时的表已经很大（目前的阈值为50000），则改变策略，采用加一倍的方法。引入这种改变策略的方式，
　　　　是为了避免出现过多空闲的存储位置。

六 栈

 1 栈的概念：

1 栈（stack）是一种容器，可存入数据元素、访问元素、删除元素。
2 它的特点在于只能允许在容器的一端（称为栈顶端指标）进行加入数据（push）和输出数据（pop）的运算。
3 没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。
4 由于栈数据结构只允许在一端进行操作，因而按照后进先出（Last In First Out）的原理运作，简称LIFO。

2 栈（ADT）的操作

1 Stack() 创建一个新的空栈
2 push(item) 添加一个新的元素item到栈顶
3 pop() 弹出栈顶元素
4 peek() 返回栈顶元素
5 is_empty() 判断栈是否为空
6 size() 返回栈的元素个数

3 栈的代码实现

class Stack:
    # 初始化空栈
    def __init__(self):
        self.__list = []

    def push(self, item):
        self.__list.append(item)

    def pop(self):
        if self.__list:
            return self.__list.pop()
        else:
            return None

    def peek(self):
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        return self.__list is None

    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    print(s.pop())
    print(s.pop())
    print(s.pop())

七：队列

1 什么是队列

1 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
2 队列是一种先进先出的（First In First Out）的线性表，简称FIFO。

2 队列的操作

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

3 队列功能的实现

# 定义队列
class Queue:
    # 初始化
    def __init__(self):
        self.__list = []
    def enqueue(self,item):
        self.__list.append(item)
    def dequeue(self):
        return self.__list.pop(0)
    def is_empty(self):
        return self.__list is None
    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    print(q.dequeue())
    print(q.dequeue())
    print(q.dequeue())

八、双端队列

1 什么是双端队列

1 双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。
2 双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

2 双端队列的操作

1 Deque() 创建一个空的双端队列
2 add_front(item) 从队头加入一个item元素
3 add_rear(item) 从队尾加入一个item元素
4 pop_front() 从队头取一个item元素
5 pop_rear() 从队尾取一个item元素
6 is_empty() 判断双端队列是否为空
7 size() 返回队列的大小

3 双端队列的代码实现

class Deque:
    def __init__(self):
        self.__list = []
    def add_front(self,item):
        self.__list.insert(0,item)
    def add_rear(self,item):
        self.__list.append(item)
    def pop_front(self):
        return self.__list.pop(0)
    def pop_rear(self):
        return self.__list.pop()

    def is_empty(self):
        return self.__list is None

    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    d = Deque()
    d.add_front(1)
    d.add_front(2)
    d.add_rear(3)
    d.add_rear(4)
    print(d.size())
    print(d.pop_front())
    print(d.pop_front())
    print(d.pop_rear())
    print(d.pop_rear())