数据结构——线性结构（列表、栈、队列）

一、列表/数组

　　列表（其他语言称数组）是一种基本数据结构。

1、列表的元素是如何存储的？

　　c的数组和python的列表有两点不同：

　　（1）数组元素类型要相同，列表元素类型可以不一样。

　　　　python存的不是真实的值而是存的内存地址。

　　　　32位机器上一个地址占4个字节，64位机器上一个地址占用8个字节。

　　（2）数组长度固定，python是长度不够了就自动开新的内存地址，把原来的内容拷过来。

2、列表基本操作时间复杂度？

　　append：不考虑python做得复制操作，大概是O(1)

　　insert：时间复杂度是O(n)，在插入后，后面的元素都要往后挪动。

　　pop\remove：pop最后一个是O(1)，写了参数则是O(n)，前面的删了后，后面的都要往前挪。

二、栈（Stack）

1、栈的定义和特点

　　栈的定义：栈是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。

　　栈的特点：后进先出（last-in,first-out）, 简称LIFO表。类似一摞书：

　　

2、栈的概念和基本操作

　　栈的概念：

　　　　栈顶：允许插入和删除的这一端称为栈顶。

　　　　栈底：另外固定的这一端称为栈底。

　　　　空栈：不含任何元素的栈称为空栈。

　　栈的基本操作：

　　　　进栈（压栈）：push

　　　　出栈：pop

　　　　取栈顶：gettop（查看栈顶元素，但不取走）  li[-1]

　　

3、栈的python实现

　　使用一般的列表结构即可实现栈：

• • 进栈：li.append
  • 出栈：li.pop
  • 取栈顶：li[-1]　　　　

class Stack:
    """栈"""
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        if len(self.stack) > 0:
            return self.stack.pop()
        else:
            print("栈已经空了")

    def get_top(self):
        if len(self.stack) > 0:  # 判断栈是否为空
            return self.stack[-1]
        else:
            return None


stack = Stack()
stack.push(1)
stack.push(2)
stack.push(6)
print(stack.pop())   # 6

　　更简单的方式实现栈的方法：创建一个列表，只使用append和pop方法进行操作。

4、栈的应用——括号匹配问题

　　括号匹配问题：给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。

　　例如：

()()[]{}      匹配
([{()}])      匹配
[](             不匹配
[(])            不匹配

　　代码实现如下所示：

class Stack:
    """栈"""
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        if len(self.stack) > 0:
            return self.stack.pop()
        else:
            print("栈已经空了")

    def get_top(self):
        if len(self.stack) > 0:  # 判断栈是否为空
            return self.stack[-1]
        else:
            return None

    def is_empty(self):
        """判断是否为空"""
        return len(self.stack) == 0


def brace_match(s):
    """括号匹配"""
    match = {'}':'{', ']':'[', ')':'('}    # 右括号为键，左括号为值
    stack = Stack()
    for ch in s:   # 获取一个个字符
        if ch in {'(','[','{'}:
            stack.push(ch)
        else:   # ch in {')',']','}'}
            if stack.is_empty():  # 如果栈为空
                return False
            elif stack.get_top() == match[ch]:
                stack.pop()
            else:   # stack.get_top() != match[ch]
                return False

    if stack.is_empty():  # 如果栈是空的了
        return True
    else:
        return False

print(brace_match('(){}[{()}]'))     # True
print(brace_match('(){}[{[(])}]'))   # False

三、队列（Queue）

1、队列概念

　　队列是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

　　进行插入的一端称为队尾(rear)，插入动作称为进队或入队。

　　进行删除的一端称为队头(front)，删除动作称为出队。

　　队列的性质：先进先出（First-in,First-out）

　　

2、思考队列能否用列表简单实现？

　　初步设想：列表+两个下标指针；创建一个列表和两个变量，front变量指向队首，rear变量指向队尾。初始时，front和rear都为0。

　　进队操作：元素写到li[rear]的位置，rear自增1。

　　出队操作：返回li[front]的元素，front自减1。

　　

　　这种实现方式不好，在一次次增减中，前面的大量内存空间都被浪费了。

3、队列的实现方式——环形队列

　　

实现方式：取余数运算

注意：队满状态下还空着一个位子，之所以不填上，是为了防止不能判别出来队到底是空的还是满的。

　　环形队列：当队尾指针front == Maxsize - 1时，再前进一个位置就自动到0。

• 队首指针前进1：front = (front + 1) % MaxSize
• 队尾指针前进1：rear = (rear + 1) % MaxSize
• 队空条件：rear == front
• 队满条件：(rear + 1) % MaxSize == front

4、队列代码实现

class Queue:
    """队列"""
    def __init__(self, size=100):
        self.queue = [0 for _ in range(size)]   # 创建固定长的列表作为队列
        self.size = size
        self.rear = 0    # 队尾指针
        self.front = 0   # 队首指针

    def push(self, element):
        """进队"""
        if not self.is_filled():
            self.rear = (self.rear + 1) % self.size    # 队尾指针前进一
            self.queue[self.rear] = element            # 添加元素
        else:
            raise IndexError("Queue is filled")

    def pop(self,):
        """出队"""
        if not self.is_empty():
            self.front = (self.front + 1) % self.size  # 队首指针前进1
            return self.queue[self.front]              # 返回新的front值
        else:
            raise IndexError("Queue is empty")  # 队列为空抛出错误

    def is_empty(self):
        """判断队空"""
        return self.rear == self.front    # 队空条件：rear == front

    def is_filled(self):
        """判断队满"""
        return (self.rear + 1) % self.size == self.front   # 队满条件：(rear + 1) % MaxSize == front


q = Queue(5)
for i in range(4):
    q.push(i)

print(q.is_filled())   # True
print(q.pop())    # 0
q.push(3)
print(q)   # <__main__.Queue object at 0x10401ae48>

5、双向队列

　　双向队列的两端都支持进队和出队操作。

　　双向队列的基本操作：队首进队/队首出队、队尾进队/队尾出队。

　　

6、python队列内置模块

　　之前学习过的queue是用来保证线程安全的，使用方法：from collections import deque，在collections中有一些数据结构，其中就包含了deque(双向队列)。

• 创建队列：queue = deque(li)
• 进队：append
• 出队：popleft
• 双向队列队首进队：appendleft
• 双向队列队尾进队：pop

from collections import deque

"""
deque([iterable[, maxlen]])   
    参数：列表、最大队列
"""
# q = deque()  # 创建队列
q = deque([1,2,3], 5)
q.append(1)    # 队尾进队
print(q.popleft())  # 1    队首出队


# 用于双向队列
q.appendleft(1)   # 队首进队
q.pop()    # 队尾出队

　　可以使用这个内置模块来模拟一个linux系统的tail命令来读取文件的最后几行：

from collections import deque

def tail(n):
    with open('test.txt', 'r') as f:
        q = deque(f, n)
        return q

for line in tail(5):
    print(line, end='')
"""
23e234
2342352
dfe232
dwwdwewew
wedwewf
"""