Python实现栈与队列

一、实现栈的基本操作
1.Stack()创建一个新的空栈。它不需要参数，并返回一个空栈。

2.push(item)将新项添加到堆栈的顶部。它需要参数 item 并且没有返回值。

3.pop()从栈顶删除项目。它不需要参数，返回 item。栈被修改。

4.peek()返回栈顶的项，不删除它。它不需要参数。堆栈不被修改。

5.is_empty()测试看栈是否为空。它不需要参数，返回一个布尔值。

6.size()返回栈的项目数。它不需要参数，返回一个整数。

# -*- coding: utf-8 -*-

'''请在Begin-End之间补充代码, 完成Stack类'''
class Stack():
    # 创建空列表实现栈
    def __init__(self): 
        self.__list = []
  
    # 判断是否为空，输出为True或False
    def is_empty(self): 
        # ********** Begin ********** #
        if len(self.__list):
            return False
        else:
            return True

        # ********** End ********** #   
    # 压栈，添加元素
    def push(self,item): 
        # ********** Begin ********** #
        self.__list.append(item)

        # ********** End ********** #  
    # 弹栈，弹出最后压入栈的元素
    def pop(self): 
        # ********** Begin ********** #
        if self.is_empty():
            return 
        else:
            return self.__list.pop()
        # ********** End ********** #  
    # 栈的长度
    def size(self):
        # ********** Begin ********** #
        return len(self.__list)

        # ********** End ********** #      

if __name__ == "__main__":
    stack = Stack() 
    nums = input().split()
    # 将nums中的元素依次入栈
    for num in nums:
        stack.push(num)
    # 打印栈的长度
    print(stack.size())
    # 将栈中元素依次弹出
    while not stack.is_empty():
        print(stack.pop(), end = ' ')

二、栈应用之括号匹配问题
任务：编写程序检查该字符串的括号是否成对出现。
判断字符串是否有效，即字符串中括号是否成对出现。若是，则输出 True ，否则输出 False 。其中字符串的字符只包含三种括号，花括号{}、中括号[]、圆括号()，即它仅由 (、)、[、]、{、}六个字符组成。

S1：遍历输入的括号序列，如果是左括号，进入S2，如果是右括号，进入S3；

S2：如果当前遍历到左括号，则入栈；

S3：如果当前遍历到右括号，则出栈一个元素，看其是否与当前的右括号组成一对，如果不是，则匹配失败。或者在出栈过程中发生异常（从空栈中出栈），也匹配失败；

S4：若能顺利遍历完成，检查栈中是否还有剩余元素，如果有，则匹配失败；如果没有，则匹配成功。

# -*- coding: utf-8 -*-

class Stack():
    # 创建空列表实现栈
    def __init__(self): 
        self.__list = []  
    # 判断是否为空
    def is_empty(self): 
        return self.__list == []
    # 压栈，添加元素
    def push(self,item): 
        self.__list.append(item)
    # 弹栈，弹出最后压入栈的元素
    def pop(self): 
        if self.is_empty():
            return 
        else:
            return self.__list.pop() 
        
'''请在Begin-End之间补充完成代码, 完成syntaxChecker函数, 解决括号匹配问题'''
def syntaxChecker(strList):
    ### strList: 字符串列表
    stack = Stack()#建立一个实例对象
    left = '([{'     # 左括号
    right = ')]}'    # 右括号
    flag = True      # 标志位
    # ********** Begin ********** #
    flag = 0#创建标志位
    for item in strList:#依次取出元素
        if item in left:#如果元素在left中，进入队列
            stack.push(item)
        if item in right:#如果元素在right中
            if stack.is_empty():#如果此时栈为空，说明括号不匹配，使用break结束
                flag = 1#将标志位定位1
                break
            else:#否则
                j = stack.pop()#将栈中的元素取出并赋值给j
                if left.find(j)!= right.find(item):#如果两个元素值不相同，说明不匹配，结束，如果相同继续进行比较
                    flag = 1
                    break
    if flag == 1 or stack.is_empty()==False:#在栈不为空且flag的值不为1的值，输出True，否则输出False
        print("False")
    else:
        print("True")


    # ********** End ********** # 
    return flag

if __name__ == "__main__":
    strList = input().split()
    result = syntaxChecker(strList)
    #print(result)

三、实现队列的基本操作

![在这里插入图片描述](https://img-blog.csdnimg.cn/9d3af0579a5b4fafabe90b03f5b2608f.png)
抽象数据类型 Queue 由如下操作定义：
抽象数据类型 Queue 由如下操作定义：

Queue()：创建一个空队列对象，无需参数，返回空的队列；

enqueue(item)：将数据项添加到队尾，无返回值；

dequeue()：从队首移除数据项，无需参数，返回值为队首数据项；

is_empty()：测试是否为空队列，无需参数，返回值为布尔值；

size()：返回队列中的数据项的个数，无需参数。



```python
**# -*- coding: utf-8 -*-

'''请在Begin-End之间补充代码, 完成Queue类'''
class Queue():
    # 创建空列表实现队列
    def __init__(self): 
        self.__list = []   
    # 判断是否为空
    def is_empty(self): 
        # ********** Begin ********** #
        return self.__list == []
        # ********** End ********** # 
    # 从队尾插入
    def enqueue(self,item):
        # ********** Begin ********** #
        self.__list.append(item)
        # ********** End ********** # 
    # 从队首弹出
    def dequeue(self): 
        # ********** Begin ********** #
        j = self.__list[0]
        del(self.__list[0])
        return j
        
 

        # ********** End ********** # 
    # 队列的长度
    def size(self):
        # ********** Begin ********** #
        return len(self.__list)
        # ********** End ********** # 
        
if __name__ == "__main__":
    queue = Queue() 
    nums = input().split()
    # 将nums中的元素依次送入队列
    for num in nums:
        queue.enqueue(num)
    print(queue.size())
    # 将队列中的元素依次弹出
    while not queue.is_empty():
        print(queue.dequeue(), end = ' ')
**

四、使用队列解决约瑟夫环问题
S1：将编号0,…,n−1循环压入队列；

S2：设置一个计数器，保存当前次数；

S3：当队列的长度大于1时，一直进行循环操作 S4；

S4：从队首取一个人出队，如果这个人报数正好是 m 那么就被杀掉，然后下一个人继续从1开始报数。如果不是 m 的话在重新入队，计数器继续 +1。

# -*- coding: utf-8 -*-
class Queue():
    # 创建空列表实现队列
    def __init__(self): 
        self.__list = []   
    # 判断是否为空
    def is_empty(self): 
        return self.__list == []
    # 从队尾插入
    def enqueue(self,item): 
        self.__list.insert(0, item)
    # 从队首弹出
    def dequeue(self):
        if self.is_empty():
            return 
        else:
            return self.__list.pop() 
    # 队列长度
    def size(self): 
        return len(self.__list)
def JosephusSolver(n, m):
    queue = Queue()
    result = []
    # ********** Begin ********** #
    t = 1 # 计数
    # 依次压入队中
    for i in range(n): 
        queue.enqueue(i)
    # 当队列数大于1时，进行循环
    while queue.size() > 1:
        # 当计数满m次时，重置计数器t，弹出队首元素，并保存到result中
        if t == m: 
            x = queue.dequeue() # 弹出x
            result.append(x)
            t = 1
        # 否则，将队首元素重新放到队尾，增加计数次数
        else: 
            x = queue.dequeue()
            queue.enqueue(x)
            t += 1
    # 完成循环后，弹出队列的余下的唯一元素
    x = queue.dequeue() # 弹出x
    result.append(x)
    # ********** End ********** #
    return result
if __name__ == "__main__":    
    n = int(input())
    m = int(input())
    print(JosephusSolver(n,m))