算法篇05---数据结构：列表（数组）、栈、队列

• 一、列表/数组

32位机器上，一个整数占4字节（32/8），元组的存储方式如下：

数组和列表有两点不同（其他语言称为数组）：

• 1. 数组元素类型要相同
• 2.数组长度固定，python中可以append

python列表如何实现：

• python列表中存的类型可以不一样，因此，列表中存的不是值，是地址。一个地址占4个字节，因此列表中每个元素内存大小一样。

时间复杂度： 

• . append()    O(1)
• . pop()     O(n)
• . insert()   O(n)
• . remove()   O(n)

二、栈

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

特点： 后进先出 LIFO（last-in , first_out）    例如摞一堆书，后放在上面的可以先拿走

如果将其看作一个列表，只能从后面进行插入或者删除.

       

栈的概念： 栈顶、栈底

栈的基本操作： 进栈\压栈（push）   出栈（pop）   取栈顶（gettop）

 1. 了解了栈的结构，如何实现栈结构：用列表就可以实现：

• 进栈push ： li .append()
• 出栈pop :   li .pop()
• 取栈顶gettop ：  li [-1]

栈结构的实现：

# 创建一个栈类：进栈、出栈、取栈顶、判断栈是否为空
class Stack(object):
    def __init__(self):
        self.stack = []
    def push(self,element):   # 进栈
        self.stack.append(element)
    def pop(self):    # 出栈
        return self.stack.pop()
    def gettop(self):    # 得到栈顶
        if len(self.stack)>0:
            return self.stack[-1]
        else:
            return None
    def is_empty(self):
        return len(self.stack) == 0

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

2.  栈的应用---括号匹配问题

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

# 创建一个栈类：进栈、出栈、取栈顶、判断栈是否为空
class Stack(object):
    def __init__(self):
        self.stack = []
    def push(self,element):   # 进栈
        self.stack.append(element)
    def pop(self):    # 出栈
        return self.stack.pop()
    def gettop(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):
    pairs={
        '}':'{',
        ']':'[',
        ')':'('
    }
    stack = Stack()  # 创建一个栈对象，后进先出
    for item in s:
        if item in {'{','[','('}:  #是否在集合内
            stack.push(item)
        # 遇到左括号进栈
        else:
            if stack.gettop() == pairs[item]:
                stack.pop()   # 栈顶和出现的右括号匹配，从栈中删去
            elif stack.is_empty() or stack.gettop() != stack[item]:
                return False

    # if len(stack) == 0:
    # if not stack:
    if stack.is_empty():
        return True
    else:
        return False


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

二、队列

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

• 进行插入的一端叫队尾（rear），插入动作称为进队或入队
• 进行删除的一端叫队头（front)，删除动作叫出队
• 队列的性质：先进先出（First-in，first-out）

 队列能否用列表简单实现？不能。复杂度太大或者浪费资源。

 队列的实现方式——环形队列。

 环形队列：

当队尾指针 rear == Maxsize-1 时，再前进一个位置（进队）就自动到0位置

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

# 队列的实现（环形队列）
class Queue(object):
    def __init__(self,size=100):
        self.queue = [0 for _ in range(size)]
        self.size = size
        self.rear = 0
        self.front = 0

    def rear_push(self,element):   # 队尾进队
        self.rear = (self.rear+1) % self.size
        self.queue[self.rear] = element

    def front_pop(self):
        self.front = (self.front+1) % self.size
        return self.queue[self.front]

    def is_empty(self):
        return self.rear==self.front

    def is_filled(self):
        return (self.rear+1) % self.size == self.front

q=Queue(5)
for i in range(4):    # size=5,最大只能存4个数据
    q.rear_push(i)
print(q.is_filled())     # True
print(q.front_pop())   # 0 ,先进先出
print(q.is_filled())    # 队头出去一个数据：False
q.rear_push(8)          # 队尾加入一个数据
print(q.is_filled())    # True