1.2 栈

1.2.1 栈的概念

栈,就像放在箱子里的衣服,叠成一摞的盘子:先放进去的后拿出来,后放进去的先拿出来(没准底下的永远都用不到)

实际的应用场景很多,比如计算数学表达式,递归函数等。

1.2.2 栈的基本操作

1.2.3 栈的线性表实现(顺序表实现、链表实现)

注意到:当用顺序表实现堆栈的时候,应该用表尾作为操作的出口,因为如果在开头加入元素复杂度是O(n),尾部插入是O(1)。

顺序表实现
class List_stack():
    def __init__(self,top=-1,full=20):
        self._top = top
        self._stack=[]
        self.full = full
    def is__full(self):
        return self.full == self._top+1
    def is_empty(self):
        return self._top == -1
    def put(self,x):
        if self.full == self._top:
            print("堆栈已满")
        else:
            self._stack.append(x)
            self._top += 1
    def pop(self):
        if self._top == -1:
            print("堆栈为空,不可弹出")
        else:
            self._top -= 1
            return self._stack[self._top+1]
链表实现(在链表的基础上定义子类)
class Lnote():  #先定义一个最小元素类,节点
    def __init__(self,ele,next_=None):  #  非常值得注意的是:next_存的不是所谓的下一个节点的地址,而是下一个节点!!!
        self.next_ = next_
        self.elem = ele


class Llist(): # 实现节点链接对象
    def __init__(self):
        self._head = None  # 表头节点
        
    def delete_list(self):
        self._head = None #  注意,头部变量一直都是一个节点类
        
    def is_empty (self):
        return self._head ==None
    
    def insert_ele(self,i,ele):
        if i ==0 :#首端插入
            self._head = Lnote(ele,self._head) # 新的节点,赋予给表头self.head ,另外:原表头的表头变量  给 新表头的_next
        if i != 0:
            p = self._head
            while p is not None and i>1:  # 找到第 i-1 个元素
                i -= 1
                p = p.next_
            pre = p
            new_note = Lnote(ele,pre.next_)
            pre.next_ = new_note
    def list_elements(self):   #  就是一个生成器了,生成器会自动提供遍历机制(相当一个列表了)比较规范
        p = self._head
        while p is not None:
            yield p.elem
            p = p.next_
    def print_me(self):
        for i in self.list_elements():
            print(i)
            
    def pop_me(self,i):
        p = self._head   #  这一点很重要
        while p  is not None and i>1:
            i -= 1
            p = p.next_
        if i==0 and p is not None:
            p0 =p
            p = p.next_
            self._head = p
            return p0.elem 
        else:
            p.next_ =p.next_.next_
        self._head = p
        

    def  find_it(self,n):  #  找到第一个值,第二个为n的元素?利用生成器阿
        for i ,j in enumerate(self.list_elements()):  # 生成器可以看成 既定列表 牛逼
            if n == j :
                print(i)
                
        
            
        

            

子类:

#  栈的链表实现
#  由链表的表头为栈的进出口,
#因为top指向无法往回,即指针无法向栈底运动


from noteList import Llist

class l2_stack(Llist):
    def __init__(self):
        super().__init__()
        self._data = Llist()
    def is_empty(self):
        return self._data._head ==None
    def push(self,ele):
        self._data.insert_ele(0,ele)
    def pop(self):
        if self._data._head ==None:
            print("栈内无元素")
        else:
            return self._data.pop_me(0)
        
1.2.4 练习题

1. 括号匹配

p140

2. 表达式的计算

p143

3. 栈与递归

p151

扫描二维码关注公众号,回复: 1929316 查看本文章


猜你喜欢

转载自blog.csdn.net/tommy1295/article/details/80740054