栈与队列的介绍_以Python为例

数据结构篇——栈与队列（以Python为例）

一、栈介绍

栈（Stack），又称堆栈，是一种运算受限的线性表。限定只能在表尾进行插入和删除操作，也即栈顶，另一端则被称为栈底。栈的插入和删除操作分别被成为压栈（Push）和出栈（Pop），进出栈操作满足后进先出原则，即Last-in First-out(LIFO)策略。在执行出栈操作之前，需要先判断栈是否为空，否则会出现栈下溢错误，在执行入栈操作之前，需要先判断栈是否已满，否则会出现栈上溢错误。

二、栈的实现

栈的结构可以形象展示如下图所示：

• 定义栈

class Stack(object):
    """创建一个栈的类"""
    def __init__(self, size=0):
        """
        创建一个空栈，并指定栈的大小为size，
        初始化栈顶元素位置为-1，每增加一个元素top加1，每减少一个元素top减1
        """
        self.items = []
        self.size = size
        self.top = -1

    def is_empty(self):
        """判断栈是否为空"""
        return self.top == -1

    def is_full(self):
        """判断栈是否已满"""
        return self.top + 1 == self.size

    def print_stack(self):
        """打印栈的内容"""
        print(self.items)

    def length(self):
        """统计栈中元素的数量"""
        return self.top + 1

    def peek(self):
        """找出栈中的顶部项"""
        if self.is_empty():     # 调用is_empty方法，判断栈是否为空，若为空则返回None，若不为空，则返回栈顶元素
            print("Stack is empty, which do not exist any item!")
            return None
        return self.items[-1]

    def pop(self):
        """出栈，删除栈的顶部元素"""
        if self.is_empty():     # 调用is_empty方法，判断栈是否为空，若为空则返回None，若不为空，则返回栈顶元素
            print("Stack is empty, which do not exist any item!")
            return None
        self.items.pop()
        self.top -= 1

    def push(self, item):
        """压栈，在栈的顶部添加元素item"""
        if self.is_full():      # 调用is_full方法，判断栈是否已满，若已满则返回None，若未满，则执行压栈操作
            print("Stack is full, which can not do push operation!")
            return None
        self.items.append(item)
        self.top += 1

• 栈的使用

if __name__ == '__main__':
    # 创建一个栈
    S = Stack(10)

    for i in range(1, 10, 2):
        S.push(i)           # 压栈
    S.print_stack()

    S.push("hello")
    S.print_stack()

    print(S.length())

    S.pop()
    S.print_stack()

    print(S.peek())

三、队列介绍

队列（Queue）,与栈一样也是运算受限的线性表，不过它只允许在表的前端（front）进行删除操作，即在队头出队（Dequeue），在表的后端（rear）进行插入操作，即在队尾入队（Enqueue）。出入队操作满足先进先出原则，即First-in First-out(FIFO)策略，在执行出队操作之前，需要先判断队列是否为空，否则会出现栈下溢错误，在执行入队操作之前，需要先判断队列是否已满，否则会出现栈上溢错误。

四、队列的实现

队列的结构可以形象展示如下图所示：

• 定义队列

class Queue(object):
    """创建一个队列的类"""
    def __init__(self, size=0):
        """
        创建一个空的队列，并指定队列的大小为size
        指定两个指针front和rear，一个指向出队（front）位置，一个指向入队（rear）位置
        """
        self.queue = []
        self.size = size
        self.front = -1
        self.rear = -1

    def is_empty(self):
        """判断队列是否为空"""
        return self.front == self.rear

    def is_full(self):
        """判断队列是否已满"""
        return self.rear - self.front == self.size

    def print_queue(self):
        """打印队列内容"""
        print(self.queue)

    def show_head(self):
        """读队头元素"""
        if self.is_empty():
            print("Queue is empty, which do not exist any item!")
            return None
        return self.queue[0]

    def length(self):
        """统计队列中元素的数量"""
        return self.rear - self.front

    def enqueue(self, item):
        """入队，在队列尾部添加元素item"""
        if self.is_full():
            print("Queue is full, which can not do enqueue operation!")
            return None
        self.queue.append(item)
        self.rear += 1

    def dequeue(self):
        """出队，在队列头部删除元素"""
        if self.is_empty():
            print("Queue is empty, which do not exist any item!")
            return None
        self.queue.pop(0)
        self.front += 1

• 队列的使用

if __name__ == '__main__':
    Q = Queue(6)
    print(Q.is_empty())

    for i in range(0, 10, 2):
        Q.enqueue(i)
    Q.print_queue()
    print(Q.rear, Q.front)      # 打印头部和尾部位置

    print(Q.show_head())
    Q.dequeue()
    Q.print_queue()
    print(Q.rear, Q.front)  # 打印头部和尾部位置

    print(Q.length())