数据结构复习之栈和队列

栈

1. 栈的定义：栈是一种只能删除顶部元素并且只能在顶部添加元素的数据结构。
2. 栈的理解：栈就是一个放书的大木箱，元素是书，你只能获取和移除最上层的书并且你只能在最上层加入书籍。
3. 栈的特点：先进后出(First In Last Out)。
4. 主要方法：1.push:将元素加入栈顶。2.pop:删除最上层元素。

具体实现（python）
注：以下是使用指针的方法实现，当然python不用这么麻烦。只是我练手工具。

class Stack:

    def __init__(self, max_size):
        self._stack = []
        self.top = -1  # 指针
        self.max_size = max_size  # 栈的最大容量

    def isEmpty(self):
        return self.top == -1

    def isFull(self):
        return self.top == self.max_size

    def push(self, item):
        if not self.isFull():
            self._stack.append(item)
            self.top += 1

    def pop(self):
        if not self.isEmpty():
            self.top -= 1
        return self._stack[self.top + 1]

    def get_top_item(self):
        if not self.isEmpty():
            return self._stack[self.top]
        return None
    
    def claer(self):
        self.top = -1

    def size(self):
        return self.top + 1

以下是测试代码

stack=Stack(4)
print(stack.isEmpty())
stack.push(5)
stack.push(6)
stack.push(7)
stack.push(8)
print(stack.isFull())
print(stack.size())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.isEmpty())

输出结果

True
False
4
8
7
6
5
True

队列

1. 队列的定义：队列是一种只能删除并获取头部元素且只能在尾部添加元素的数据结构。
2. 队列的理解：队列和平时排队买奶茶做对比，人是元素，假设不存在插队现象且队中间人不能中途离场，人要想排队必须要站在队尾等待，买完奶茶的人从队首离队。
3. 队列的特点：先进先出(First In First Out)。
4. 主要方法：1.enQueue:将元素加入队尾。2.deQueue:将队首元素删除。

具体实现
注：以下是环形队列的实现，python不用这么麻烦。只是用python练练手，模拟实现而已。python直接pop()和append()就实现了。

class Queue:

    def __init__(self, max_size):
        self._ringQueue = [None] * (max_size + 1)
        self.max_size = max_size
        self.rear = 0  # 尾部指针
        self.front = 0  # 头部指针

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

    def isFull(self):
        return self.front - self.rear == 1 if self.front > self.rear else self.front - \
            self.rear == -self.max_size

    def enQueue(self, item):
        if not self.isFull():
            self._ringQueue[self.rear] = item
            self.rear = (self.rear + 1) % (self.max_size+1)

    def deQueue(self):
        if not self.isEmpty():
            item = self._ringQueue[self.front]
            self.front = (self.front + 1) % (self.max_size+1)
            return item

    def get_item(self):
        if not self.isEmpty():
            return self._ringQueue[self.front]

    def claer(self):
        self.rear = 0
        self.front = 0

    def size(self):
        return self.rear - self.front if self.front <= self.rear else self.rear + \
            self.max_size - self.front + 1

以下是测试代码

queue= Queue(3)
queue.enQueue(1)
queue.enQueue(2)
print(queue.size())
queue.enQueue(3)
print(queue.deQueue())
print(queue.deQueue())
print(queue.deQueue())
print(queue.deQueue())

输出结果

2
1
2
3
None