[数据结构] 栈&队列

一. 栈（stack）

栈是限定只能在一端进行插入和删除操作的线性数据结构，具有后进先出(last in first out，LIFO)的特征.

　　  

 

栈允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零 时称为空栈。插入一般称为进栈（PUSH），删除则称为出栈（POP）。对于进栈和出栈而言，时间复杂度都为O(1).

 

(一). 栈的Python实现

对于stack, 可以使用python内置的list实现. list属于线性表，可以用下标为0的一端作为栈底, 定义一个top变量来指向栈顶元素在数组中的位置.

class Stack(object):
    def __init__(self, limit = 20):
        self.items = []    # 初始化为空列表
        self.limit = limit    # 指定栈的容量


    '''判断栈是否为空，返回布尔值'''
    def is_empty(self):
        return self.items == []


    '''返回栈的大小'''
    def size(self):
        if self.items:
            return len(self.items)


    '''查看堆栈最上面的元素'''
    def peek(self):
        if self.items:
            return self.items[len(self.items)-1]


    '''入栈'''
    def push(self,value):
        if len(self.items) >= self.limit:
            raise IndexError('index out of range!')
        else:
            self.items.append(value)


    '''出栈'''
    def pop(self):
        if self.items:
            self.items.pop()
        else:
            raise IndexError('can not pop item from an empty stack')


# 测试
if __name__ ==  "__main__":
    # 初始化一个栈对象
    my_stack = Stack()
    my_stack.push('a')
    my_stack.push('bc')
    print(my_stack.size())
    print('---1---')
    print(my_stack.peek())
    print('---2---')
    my_stack.pop()
    print(my_stack.peek())
    print('---3---')
    print(my_stack.size())
    print('---4---')
    my_stack.pop()
    print(my_stack.is_empty())

tips. 实际应用中, 栈不需要我们自己定义，使用列表结构即可：

　　1. 进栈：append

　　2. 出栈：pop

　　3. 查看栈顶：list [-1] 直接取索引

 

(二). 栈的常见应用

1. 递归 -- 斐波那契数列

　Fibonacci数列定义: f(0) = 0,  f(1) = 1,  f(n) = f(n-1) + f(n-2)

'''栈的应用 -- 1. 递归'''
# 实现斐波那契数列

def fibonacci_recursion(n):
    if n < 2:
        return n
    else:
        return fibonacci_recursion(n-1) + fibonacci_recursion(n-2)

# 测试
if __name__ == "__main__":
    input = int(input('请输入数字:'))
    if input < 0:
        print('请输入正整数')
    else:
        print(fibonacci_recursion(input))

 

2. 括号匹配

　 思路:

　 (1). 只要碰到左括号, 进栈;

　 (2). 一旦碰到右括号, 先判断栈顶与当前字符是否是一对;

　 (3). 如果匹配, 就让栈顶的左括号出栈, 继续下一个字符;

　 (4). 如果不匹配, 直接return False;

def balance_parentheses(parentheses):
    stack = Stack(len(parentheses))   # 初始化一个栈(数组)
    balance = {'}':'{', ')':'(', ']':'[', '>':'<','》':'《'}    # 字典:方便一一对应
    for parenthesis in parentheses:
        if parenthesis in balance.values():    # 如果是左括号
            stack.append(parenthesis)
        elif parenthesis in balance.keys():
            if balance[parenthesis] != stack.pop():
                return False
    return True

# 测试
if __name__ == "__main__":
    examples = ['((){})《','()()<>()(','','(({})))']
    for example in examples:
        print(example+':'+ str(balance_parentheses(example)))

 

 二. 队列 

 队列(queue)是一种具有先进先出特征的线性数据结构，元素的增加只能在一端进行，元素的删除只能在另一端进行。能够增加元素的队列一端称为队尾，可以删除元素的队列一端则称为队首.

   

 队列符合先进先出[FIFO]的原则.

 队列有两种实现形式：数组和链表.

 队列属于常见的一种线性结构，对于出队和进队而言，时间复杂度都为 O(1).

 

(一). 队列的python实现

对于queue, 可以使用列表简单模拟队列. 可以用下标为0的一端作为队头,保证先进的先出. 队尾就是list[len(list)-1] 这个元素.

# python 实现队列
class Queue(object):
    def __init__(self, size):
        self.size = size
        self.queue = []

    '''判断队列是否满了'''
    def is_full(self):
        if len(self.queue) == self.size:
            return True
        return False

    '''判断队列是否为空'''
    def is_empty(self):
        return self.queue == []

    '''获取当前队列的长度'''
    def get_length(self):
        return len(self.queue)

    '''入队'''
    def enqueue(self,item):
        if self.is_full():
            raise IndexError('full error')
        self.queue.append(item)

    '''出队'''
    def dequeue(self):
        if self.is_empty():
            raise IndexError('empty error')
        first_ele = self.queue[0]
        self.queue.remove(first_ele)
        return first_ele

# 测试
if __name__ == '__main__' :
  queueTest = Queue(5)
  for i in range(5) :
    queueTest.enqueue(i)
  print(queueTest.is_full())
  print(queueTest.get_length())
  queueTest.dequeue()
  print(queueTest.is_empty())
  print(queueTest.get_length())

 

(二). python内置的队列模块  --  queue

 Python有自己的队列模块，我们只需要在使用时引入该模块就行.并且支持双向队列,优先级队列等;

 

 [ 队列分类 ]:

      

 

 [ 队列的方法 ]:

      

　　

1. 单向队列

from collections import Queue

q = queue.Queue(10)    # 不设置长度的话,默认为无限长度
print(q.maxsize)    # 无括号
q.put(111)
q.put('abc')
q.put(['d','f'])
print(q.get())
print(q.get())
print(q.get())

-------------
10
111
abc
['d', 'f']

 

2. 后进先出队列

from collections import LifoQueue

q = queue.LifoQueue(10)    # 不设置长度的话,默认为无限长度
print(q.maxsize)    # 无括号
q.put(111)
q.put('abc')
q.put(['d','f'])
print(q.get())
print(q.get())
print(q.get())

------------
10
['d', 'f']
abc
111

 

3.优先级队列

优先级队列put的是一个元组，(优先级,数据)，优先级数越小，级别越高.

from collections import PriorityQueue

q = queue.PriorityQueue()
print(q.maxsize)    # 无括号
q.put((1,'111'))
q.put((2,'abc'))
q.put((1,'def'))
print(q.get())
print(q.get())
print(q.get())

-------------
0
(1, '111')
(1, 'def')
(2, 'abc')

 

4. 双线队列

from collections import deque

q = queue.deque()
q.append(111)
q.append('abc')
q.appendleft('def')
print(q)
print(q.pop())
print(q.popleft())

---------------

deque(['def', 111, 'abc'])
abc
def

 

  🔚👋