数据结构与算法Day4栈和队列

栈和队列

总概

双端队列中的。

名称	栈（stack），又称为堆栈	队列	双端队列
操作	可存入、访问、删除数据元素	可存入、删除数据元素	可存入、删除数据元素
特点	只能允许在容器的一端（称为栈顶端指标，top）进行加入数据（push）和输出数据（pop，出栈）	只允许在一端（队尾）进行插入操作， 而在**另一端（队头）**进行删除操作的线性表	元素可以从两端弹出，其限定插入和删除操作在表的两端进行
访问顺序	没有位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素	可删除的元素是第一个存入的元素	双端队列可以在队列任意一端入队和出队
运作原理	后进先出（=LIFO, Last In First Out）	先进先出（First In First Out）	具有队列和栈的性质的数据结构

栈、队列	列表、链表
描述数据操作	描述数据存放

栈

栈结构的实现

栈可以用顺序表实现，也可以用链表实现。

操作	表示
Stack()	创建一个新的空栈
push(item)	添加一个新的元素item到栈顶（入栈、压栈）
pop()	弹出栈顶元素（出栈）
peek()	返回栈顶元素，但元素还在栈中，没有出栈
is_empty()	判断栈是否为空
size()	返回栈的元素个数

顺序表实现的栈

class Stack():
    """栈"""
    def __init__(self):
        """生成一个储存数据的容器"""
        self.__list=[] #对外限制操作，也可用链表self.__linklist=SingleLinkList()
        
    def push(self,item) :
        """添加一个新的元素item到栈顶（入栈、压栈）"""
        self.__list.append(item)#可选尾部和头部，由于顺序表操作的时间复杂度，选尾部
                                #用链表则选头部  self.__linklist.add(item)      
    def pop(self) :
        """弹出栈顶元素（出栈）"""
        if self.__list:
            return self.__list.pop()
        else:
            return None
    
    def peek(self) :
        """返回栈顶元素，但元素还在栈中，没有出栈"""
        if self.__list:
            return self.__list[-1]
        else:
            return None
    def is_empty(self) :
        """判断栈是否为空"""
        return self.__list==[]#也可用return not self.__list
    
    def size(self) :
        """返回栈的元素个数"""
        return len(self.__list)

链表实现的栈

class Stack():
    """栈"""
    def __init__(self):
        """生成一个储存数据的容器"""
        self.__linklist=SingleLinkList() 
        
    def push(self,item) :
        """添加一个新的元素item到栈顶（入栈、压栈）"""
        self.__linklist.add(item)
        
    def pop(self):
        """弹出栈顶元素（出栈）"""
        if self.__linklist:
            pop=self.__linklist._SingleLinkList__head.elem
            self.__linklist._SingleLinkList__head= self.__linklist._SingleLinkList__head.next
            return pop
        else:
            return None
          
    def peek(self) :
        """返回栈顶元素，但元素还在栈中，没有出栈"""
        if self.__linklist:
            return self.__linklist._SingleLinkList__head.elem
        else:
            return None
        
    def is_empty(self) :
        """判断栈是否为空"""
        return self.__linklist.is_empty()
        
    def size(self) :
        """返回栈的元素个数"""
        return self.__linklist.length()

队列

队列结构的实现

同栈一样，队列也可以用顺序表或者链表实现。

操作	表示
Queue()	创建一个空的队列
enqueue(item)	往队列中添加一个item元素（入队）
dequeue()	从队列头部删除一个元素（出队）
is_empty()	判断一个队列是否为空
size()	返回队列的大小

顺序表实现的队列

class Queue():
    """创建一个队列"""
    def __init__(self):
        """生成一个储存数据的容器"""
        self.__list=[]
        
    def enqueue(self,item): 
        """往队列中添加一个item元素"""
        self.__list.append(item)  #不论是在尾部添加还是头部添加
                        #总有一个时间时间复杂度是O(1)另一个O(n),根据操作频率选择
        
    def dequeue(self): 
        """从队列头部删除一个元素"""
        if self.__list:
            return self.__list.pop(0)
        else:
            return None
        
    def is_empty(self): 
        """判断一个队列是否为空"""
        return self.__list==[]
    
    
    def size(self): 
        """返回队列的大小"""
        return len(self.__list)

链表实现的队列

class Queue():
    """创建一个队列"""
    def __init__(self):
        """生成一个储存数据的容器"""
        self.__linklist=SingleLinkList() 
        
    def enqueue(self,item): 
        """往队列中添加一个item元素"""
        self.__linklist.append(item) #不论是在尾部添加还是头部添加
                        #总有一个时间时间复杂度是O(1)另一个O(n),根据操作频率选择
        
    def dequeue(self): 
        """从队列头部删除一个元素"""
        if self.__linklist:
            pop=self.__linklist._SingleLinkList__head.elem
            self.__linklist._SingleLinkList__head= self.__linklist._SingleLinkList__head.next
            return pop
        else:
            return None
        
    def is_empty(self): 
        """判断一个队列是否为空"""
        return self.__list.is_empty()
    
    def size(self): 
        """返回队列的大小"""
        return self.__linklist.length()

双端队列（double-ended queue）

双端队列的实现

操作	表示
Deque()	创建一个空的双端队列
add_front(item)	从队头加入一个item元素
add_rear(item)	从队尾加入一个item元素
remove_front()	从队头删除一个item元素
remove_rear()	从队尾删除一个item元素
is_empty()	判断双端队列是否为空
size()	返回队列的大小

顺序表实现的双端队列

class Deque():
    """创建一个队列"""
    def __init__(self):
        """生成一个储存数据的容器"""
        self.__list=[]
        
    def add_front(self,item): 
        """从队头加入一个item元素"""
        self.__list.insert(0,item) #和add_rear中的代码可交换，相应头尾部删除也要交换即可

    def add_rear(self,item): 
        """从队尾加入一个item元素"""
        self.__list.append(item)  

    def pop_front(self): 
        """从队头删除一个item元素"""
        if self.__list:
            return self.__list.pop(0)
        else:
            return None

    def pop_rear(self): 
        """从队尾删除一个item元素"""
        if self.__list:
            return self.__list.pop()
        else:
            return None

    def is_empty(self): 
        """判断一个队列是否为空"""
        return self.__list==[]


    def size(self): 
        """返回队列的大小"""
        return len(self.__list)