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

一、列表/数组

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

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]　　　　

?

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

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、栈的应用——括号匹配问题

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

　　例如：

?

1 2 3 4

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

　　代码实现如下所示：

?

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

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、队列代码实现

?

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

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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命令来读取文件的最后几行：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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 """