python栈和队列

一、栈

1. 栈的基本介绍

特点：先进后出 （last-in, first-out）

入栈：push()
出栈：pop()
栈顶：get_top()
栈中元素个数：size()
判断栈是否为空：empty()

2. 代码

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

    def push(self, element): # 入栈
        self.stack.append(element)

    def pop(self): # 出栈
        return self.stack.pop()

    def empty(self):  # 判断栈是否为空
        return self.stack == []

    def size(self):  # 返回栈中元素数量
        return len(self.stack)

    def get_top(self):# 取栈顶元素
        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

3. 基本操作

4. 括号匹配问题

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

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

    def pop(self):
        return self.stack.pop()

    def get_top(self):
        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

    def empty(self):
        return len(self.stack) == 0


def bracket(s):
    stack = Stack()
    if len(s) % 2 != 0:  # 如果括号可以匹配，那么数量一定为偶数
        return False
    for i in s:
        if i == '(':
            stack.push(')')
        elif i == '[':
            stack.push(']')
        elif i == '{':
            stack.push('}')
        elif stack.get_top() == i:
            stack.pop()
        elif stack.empty() or stack.get_top() != i:
            return False
    if stack.empty():
        return True
    else:
        return False


s = input(':')
print(bracket(s))

5. 删除字符串所有相邻的重复项

样例：

输入："abbaca"
输出："ca"

例如：
在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。

之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

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

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

    def pop(self):
        return self.stack.pop()

    def get_top(self):
        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

    def empty(self):
        return len(self.stack) == 0


def bracket(s):
    stack = Stack()
    for i in s:
        # 1. 如果栈为空 或者  前一个元素（栈顶）不等于当前元素i，则代表不是重复的，直接入栈即可
        if stack.empty() or stack.get_top() != i:
            stack.push(i)
        # 2. 如果前一个元素（栈顶） 等于 当前元素i，则需要出栈
        elif i == stack.get_top():
            stack.pop()
    # 3. 挨个遍历栈里面的元素，并加入到s中。注意：因为是从栈顶依次获取的，所有字符串s需要反转。
    s = ""
    while not stack.empty():
        s += stack.get_top()
        stack.pop()
    return s[::-1]


s = input(':')
print(bracket(s))

6. 出栈顺序是否合法

输入出栈的数字（数字不相同），判断这些数字是否可以合法入栈。

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

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

    def pop(self):
        return self.stack.pop()

    def get_top(self):
        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

    def empty(self):
        return len(self.stack) == 0


# ① 创建栈，stack为栈中
stack = Stack()
# ② 创建数组a，为栈后数组
a = [0 for i in range(10)]
# ③ 输入数字
n = int(input('你要输入几个数字：'))
for i in range(1, n + 1):
    a[i] = int(input('请输入数字：'))
print(a)
# ④ 入栈、出栈
p = 1  # p表示栈前,p始终指向它即将入栈的那一位
flag = 1
for i in range(1, n + 1):
    while a[i] >= p:  # 将i之前的所有数字入栈
        stack.push(p)  # 入栈
        p += 1
    if stack.get_top() == a[i]:  # 如果栈顶 等于 列表第i为的元素，出栈
        stack.pop()  # 出栈
    else:
        flag = 0
        break
# ⑤ 判断是否合法
if flag:
    print(True)
else:
    print(False)

二、队列

1. 队列基本介绍

特点：先进先出 （First in，First out）

入队：push()。队尾(rear)指针加1。rear=(rear+1)%MaxSize
出队：pop()。  对头(front)指针加1。front=(front+1)%MaxSize
对头元素：get_front()
对尾元素：get_back()
队列中元素个数：length()。(rear−front+MaxSize)%MaxSize
判断队是否为空：empty()。front==rear
判断队列是否满：filled()。(rear+1)%MaxSize==front

2. 队列代码

class Queue:
    def __init__(self, size):
        self.queue = [0 for _ in range(size)]
        self.size = size  # 队列最大容量
        self.rear = 0  # 队尾，负责入队
        self.front = 0  # 队头，负责出队

    # 入队
    def push(self, element):
        if not self.filled():  # 如果队不满，则入队
            self.rear = (self.rear + 1) % self.size  # 将队尾指针重新赋值，队尾需要向后移动一位
            self.queue[self.rear] = element  # 队尾插入元素
        else:
            raise IndexError("队列已满！！！")

    # 出队
    def pop(self):
        if not self.empty():  # 如果队不空，则出队
            self.front = (self.front + 1) % self.size  # 将队头指针重新赋值，对头需要向后移动一位
            return self.queue[self.front]
        else:
            raise IndexError("队列为空！！！")

    # 判断队空（队头等于队尾则代表对空）
    def empty(self):
        return self.rear == self.front

    # 判断队满
    def filled(self):
        return (self.rear + 1) % self.size == self.front

    # 队列元素个数
    def length(self):
        return (self.rear - self.front + self.size) % self.size

    # 对头元素
    def get_front(self):
        if not self.empty():  # 如果队不空，则打印对头元素
            return self.queue[(self.front + 1) % self.size]

    # 对尾元素
    def get_back(self):
        if not self.empty():  # 如果队不空，则打印对尾元素
            return self.queue[self.rear]

3. 队列基本操作

# 1. 创建队列
q = Queue(5)
# 2. 依次添加数据
q.push(1)
q.push(2)
q.push(3)
q.push(4)
# 3. 出队列
print('出队：', q.pop())
print('出队：', q.pop())
# 4. 长度、对头、队尾
print('队列长度：', q.length())
print('对头元素：', q.get_front())
print('对尾元素：', q.get_back())

# ⑤ 遍历队列
# while not q.empty():
#     print(q.pop())

while not q.empty():
    print('对头元素：', q.get_front())
    q.pop()

4. 约瑟夫环-循环嵌套

一共有n个人，第m个人负责出圈，请依次打印出圈的数字。

a = [0 for i in range(101)]
n, m, i, cnt, k = 0, 0, 0, 0, 0  # cnt：出圈人数  i:位置,从1开始  k:数数,到k，就要出圈

n = int(input('一共有几个人?'))
m = int(input('第几个人出圈？'))

while cnt != n:
    i += 1
    if i > n:  # 走到了最后一个，再回头
        i = 1
    if a[i] == 0:  # 如果为0则代表这个数还没出圈
        k += 1
        if k == m:
            a[i] = 1  # 出圈
            cnt += 1  # 出圈人数增加1
            print(i, end=' ')
            k = 0  # 重新数数

5. 约瑟夫环-队列1

# 1. 创建队列
q = Queue(20)
n = int(input('一共有几个人?'))
m = int(input('第几个人出圈？'))
# 2. 将n个人的编号按顺序依次入队
for i in range(1, n + 1):
    q.push(i)
# 3. 从1开始报数10
cnt = 1
while not q.empty():  # 只要队列不为空则一直循环
    if cnt % m == 0:  # 代表找到了
        print(q.get_front(), end=' ')
        q.pop()
        cnt = 0
    else:  # 未找到
        q.push(q.get_front())  # 把队头元素调到队尾
        q.pop()
    cnt += 1

6. 约瑟夫环-队列2

# 1. 创建队列
q = Queue(20)
n = int(input('一共有几个人?'))
m = int(input('第几个人出圈？'))
# 2. 将n个人的编号按顺序依次入队
for i in range(1, n + 1):
    q.push(i)
# 3. 将第m个数字移到队首，第m-1个数字移到队尾
while q.length() > 0:      # 删除操作，并在当队列中没有数字时停止该操作
    for i in range(1, m):  # 将队列中第m个人移到队首，并将前面m-1个人按顺序排到队尾
        h = q.get_front()
        q.pop()
        q.push(h)
    x = q.pop()
    print(x, end=' ')