栈和队列的对比和实现

栈和队列对比

栈(Stack):限定只能在表的一端进行插入和删除操作的线性表.
队列(Queue):是限定只能在表的一端进行插入,另一端删除操作的线性表.
不同之处在于队列先进先出,栈先进后出.

栈的实现

方法一(数组实现)

class Stack: #定义栈
    def __init__(self):
        self.stack=[]
        self.size=0
    def __str__(self):#转化为字符串方便打印
        return  str(self.stack)

    def push(self,data): #压栈(存入)
        if len(self.stack)<self.size:
            raise Exception("溢出")
        self.stack.append(data)
        self.size+=1
        
    def pop(self):弹栈(取出)
        if self.stack:
            popf=self.stack.pop()
            self.size-=1
            return popf
        else:
            raise Exception('空栈')
    def peek(self): #显示栈顶
        if self.stack:
            return self.stack[-1]
    def is_empty(self): #判断是否为空栈
        return not bool(self.stack)
    def size1(self): #返回栈长度注意函数名不能与原有函数冲突
        return self.size
if __name__ == '__main__':
    st=Stack()
    print(st.is_empty())
    for i in range(10):
        st.push(i)

方法二(链表实现)

class Node: #节点创建
    def __init__(self,data):
        self.data=data
        self.next=None
    def __repr__(self):
        return  f"Node({self.data})"

class  LinkStact: #链表创建用链表实现栈
    def __init__(self):
        self.top=None #定义栈顶
        self.size=0
    def push(self,data):#压栈
        new_st=Node(data)
        new_st.next=self.top
        self.top=new_st
        self.size+=1
    def pop(self): #弹栈
        if self.top is  None:
            raise Exception('空栈')
        popf=self.top
        self.top=self.top.next
        return popf.data
    def peek(self):# 显示栈顶
        if self.top is  None:
            raise Exception('空栈')

        return self.top.data
    def is_empty(self):#判断是否为空
        return not bool(self.top)
    def size1(self): #显示栈的长度
        return self.size

    def __repr__(self):  # 链表打印
        current = self.top
        string_repr = ""
        while current:
            string_repr += f"{current} --> "
            current = current.next
        return string_repr + "END"
if __name__ == '__main__':
    ll=LinkStact()
    print(ll.is_empty())
    for i in range(10):
        ll.push(i)
    print(ll)
    print(ll.size1())
    print(ll.pop())
  

队列的实现

方法一(数组实现)

class Queue:#定义队列
    def __init__(self):
        self.entries=[] #队列内容
        self.size=0 #队列长度
        
    def __str__(self):#转化为字符串方便打印
        printed="<"+str(self.entries)[1:-1]+'>'
        return printed
    def put(self,item): #入队(存入数据)
        self.entries.append(item)
        self.size+=1
    def get(self):  #出队(取出数据)
        dequeued=self.entries[0]
        self.size=self.size-1
        self.entries=self.entries[1:]
        return dequeued
    def fan(self): #反转队列
        self.entries=self.entries[::-1]
        return self.entries

    def front(self):#显示队列头部(下一个取出的数据)
        return  self.entries[0]
    def size1(self):
        return  self.size

if __name__ == '__main__':
    qu=Queue()
    for i in range(10):
        qu.put(i)
    print(qu)
    qu.get()
    print(qu)
    print(qu.size1())
    print(qu.fan())

方法二(链表实现)

玩链表必须有节点

from typing import Any ,Optional#传说中的类型引用
class Node :# 老套路定义节点
    def __init__(self,iterm:Any): #注":any"为类型注解不影响前后可以无视,下同
        self.iterm:Any=iterm
        self.next:Optional = None
    def __repr__(self):#我都不想写了字符串转化方便打印
        return f"Node({self.iterm})"
        
class LinkQueue:#队列定义
    def __init__(self):
        self.front=None #定义输入端
        self.rear=None #定义输出端
        self.size=0 # 定义长度
    def put(self,iterm): #存入
        new_node=Node(iterm)
        if self.front is None:
            self.front=new_node
            self.rear=new_node
        else:
            self.rear.next=new_node
            self.rear=new_node
        self.size+=1
    def pop(self): #取出
        if self.front is None:
            raise Exception('空队列')
        else:
            popf=self.front
            self.front=self.front.next

        self.size-=1
        return popf
    def get(self,index): #返回指定位置节点
        cur=self.front
        if index<0 or index>self.size:
            raise Exception('索引越界')

        for _ in range(1,index):
            cur=cur.next
        return cur
    def size1(self): #返回长度
        return self.size

    def __repr__(self): #链表打印
        cur = self.front
        string_repr = ""
        while cur:
            string_repr += f"{cur} --> "
            cur = cur.next
        return string_repr + "END"

if __name__ == '__main__':
    lq=LinkQueue()
    for i in range(10):
        lq.put(i)
    lq.pop()
    print(lq.get(4))
    print(lq)
    print(lq.size1())