数据结构笔记3

最新推荐文章于 2024-06-17 17:35:06 发布

幽径微澜

最新推荐文章于 2024-06-17 17:35:06 发布

阅读量483

点赞数 9

分类专栏：数据结构文章标签： python 数据结构笔记

本文链接：https://blog.csdn.net/2301_80618119/article/details/135863917

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

来自《Python数据结构学习笔记》（张清云编著）

第五章队列和栈

5.2 栈

又称堆栈，是一种运算受限的线性表。

5.2.2 入栈和出栈

Stack()：建立一个空的栈对象
push()：把一个元素添加到栈的最顶层
pop()：删除栈顶层的元素，并返回这个元素
peek()：返回顶层的元素，并不删除它
isEmpty()：判断栈是否为空
size()：返回栈中元素的个数

class Stack(object):
    """栈"""
    
    def __init__(self):
        self._list=[]
    
    def push(self,item):
        """添加一个新的元素item到栈顶"""
        self._list.append(item)

    def pop(self):
        """弹出栈顶元素"""
        return self._list.pop()

    def peek(self):
        """返回栈顶元素"""
        if sellf._list:
            return self._list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是否为空"""
        return self._list==[]

    def size(self):
        """返回栈的元素"""
        return len(self._list)

if __name__=="__main__":
    s=Stack()
    s.push(1) 
    s.push(2) 
    s.push(3) 
    s.push(4)
    print(s.pop()) 
    print(s.pop())
    print(s.pop())
    print(s.pop())

输出：

5.2.3 顺序栈

顺序栈中的元素用向量存放
栈底位置固定不变，可以设置在向量两端的任意一个端点
栈顶位置随着进栈和退栈操作而变化，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置

1.顺序栈的基本操作

（1）进栈操作

S->top加1

注意：S->top==StackSize-1表示栈满；进行“上溢”现象，即当栈满时，再进行进栈运算产生空间溢出的现象。上溢是一种出错状态，应设法避免。

（2）退栈操作

S->top减1

S->top<0表示此栈是一个空栈。如果进行退栈运算，则将会产生溢出现象。下溢是一种正常的现象，常用作程序控制转移的条件。

2.顺序栈运算

（1）使用python判断栈是否为空的算法

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

（2）使用python返回栈顶元素的算法

def peek(self):
    return self.items[len(self.items)-1]

（3）使用python返回栈的大小的算法

def size(self):
    return len(self.items)

（4）使用python把新的元素堆进栈里面（也称压栈、入栈或进栈）

def push(self,item):
    self.items.append(item)

（5）使用python把栈顶元素丢出去（也称出栈）

def pop(self,item):
    return self.items.pop()

实例：

class Stack(object):
    #初始化栈为空列表
    def __init__(self):
        self.items=[]

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

    #返回栈顶元素
    def peek(self):
        return self.items[len(self.items)-1]

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

    #把新的元素堆进栈里面（入栈）
    def push(self,item):
        self.items.append(item)

    #把栈顶元素丢出去（出栈）
    def pop(self,item):
        return self.items.pop()

if __name__=="__main__":
    #初始化一个栈对象
    my_stack=Stack()
    #把'h'丢进栈里
    my_stack.push('a')
    my_stack.push('c')
    my_stack.push('d')
    my_stack.push('e')
    #看一下栈的大小（有几个元素）
    print(my_stack.size())
    #打印栈顶元素
    print(my_stack.peek())
    #把栈顶元素丢进去，并打印出来
    #print(my_stack.pop())
    #再看一下栈顶元素是谁
    print(my_stack.peek())
    #这个时候栈的大小是多少？
    print(my_stack.size())
    #再丢一个栈顶元素
    print(my_stack.pop())
    #看一下栈的大小
    print(my_stack.size())

5.2.4 链栈

用链表的方式实现栈。

定义LinkStack结构类型的目的是为了更加便于在函数体中修改指针top
如果要记录栈中元素个数，将属性放在LinkStack中定义

（1）判断链栈是否为空

def is_empty(self):
    return self._top is None

（2）返回栈顶元素

def top(self):
    if self.is_empty():
        raise StackUnderflow("in LStack.top()")
    return self._top.elem

（3）把新的元素放进栈里面

def push(self,elem):
    self._top=Node(elem,self._top)

（4）把栈顶元素丢出去（出栈）

def pop(self):
    if self.is_empty():
        raise StackUnderflow("in LStack.pop()")
    result=self._top.elem
    self._top=self._top.next
    return result

实例：

#链表节点
class Node(object):
    def __init__(self,elem,next_=None):
        self.elem=elem    
        self.next=next_

#顺序表实现栈
class SStack(object):
    def __init__(self):
        self._elems=[]

    def is_empty(self):
        return self._elems=[]

    def top(self):
        if self.is_empty():
            raise StackUnderflow
        return self._elems[-1]

    def push(self,elem):
        self._elems.append(elem)

    def pop(self):
        if self.is_empty():
            raise StackUnderflow
        return self._elems.pop()

#链表实现栈
class LStack(object):
    def __init__(self):
        self._top=None

    def is_empty(self):
        return self._top is None
    
    def top(self):
        if self.is_empty():
            raise StackUnderflow("in LStack.top()")

    def push(self,elem):
        self._top=Node(elem,self._top)

    def pop(self):
        if self.is_empty():
            raise StackUnderflow("in LStack.pop()")
        result=self._top.elem
        self._top=self._top.next
        return result

if __name__=="__main__":
    st1=SStack()
    st1.push(3)
    st1.push(5)
    while not st1.is_empty():
        print(st1.pop())

    print("==========")
    st2=LStack()
    st2.push(3)
    st2.push(5)
    while not st2.is_empty():
        print(st2.pop())

输出：