Python数据结构与算法—栈

栈

1.定义：栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。

2.特点：

• 栈只能在一端进行数据操作
• 栈模型具有后进先出或者叫做后进先出的规律

3.栈的代码实现

栈的操作有入栈（压栈），出栈（弹栈），判断栈的空满等操作。

"""
栈模型顺序存储
重点代码

思路分析：
1. 列表即顺序存储，但是功能太多，不符合栈模型
2. 利用列表，封装类，提供栈的接口方法
"""

#　自定义异常类
class StackError(Exception):
  pass

# 顺序栈类封装
class SStack:
  def __init__(self):
    #　属性为空列表，这个列表就是栈的存储空间
    # 列表最后一个元素为栈顶元素
    self._elems = []

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

  #　入栈 elem
  def push(self,elem):
    self._elems.append(elem)

  #　出栈
  def pop(self):
    # self._elems为空则ｉｆ语句为真
    if not self._elems:
      raise StackError("stack is empty")
    return self._elems.pop() #　弹出列表最后一个

  #　查看栈顶元素
  def top(self):
    if not self._elems:
      raise StackError("stack is empty")
    return self._elems[-1]

if __name__ == "__main__":
  st = SStack()  #　初始化栈
  st.push(10)
  st.push(20)
  st.push(30)
  while not st.is_empty():
    print(st.pop())

"""
栈的链式存储
重点代码

思路分析：
1. 基本的实现模型源于　链表
2. 栈顶位置？ 栈顶相当于链表的尾部
"""


class StackError(Exception):
    pass


# 节点类
class Node():
    def __init__(self, data, next=None):
        self.data = data
        self.next = next


# 栈类
class LStack():
    def __init__(self):
        # 尾部为None
        self.top_ = None

    # 是否为空栈
    def empty(self):
        if self.top_ is None:
            print("空栈")
        else:
            print("不是空栈")

    # 入栈
    def push(self, data):
        # 同链表p=p.next
        self.top_ = Node(data, self.top_)

    # 弹栈
    def pop(self):
        # 如果是空栈 人工报错
        if self.top_ is None:
            raise StackError("stack is empty")
        # 出栈的值为栈顶的值
        data = self.top_.data
        # 栈顶的位置向下移
        self.top_ = self.top_.next
        return data

    # 查看栈顶的值
    def get_top(self):
        if self.top_ is None:
            raise StackError("stack is empty")
        # 不是空栈的话，self.top_.data便是栈顶的值
        return self.top_.data


print("--------------测试-------------------")
if __name__ == '__main__':
    ls = LStack()
    ls.empty()  # 空栈
    ls.push(10)
    ls.push(100)
    ls.push(200)
    print(ls.get_top())  # 200
    ls.pop()
    ls.pop()
    print(ls.get_top())  # 10
    ls.empty()  # 不是空栈

练习：一段文字，可能存在括号配对错误的情况。就是少一个或者括号不一致
要求写一段代码，检测这段文字有没有括号书写异常
括号包含{}，[]，()

import 栈顺序存储模型（SStack）

st = SStack()
parens = "{}()[]"  # 需要验证的字符
left_parens = "{(["
# 验证配对是否正确
opposite_dict = {'}': '{',
                 ']': '[',
                 ')': '('}


# 负责提供遍历
def for_text(text):
  """
  遍历字符串，提供括号字符和其位置
  :param str:
  :return: 括号字符的列表和位置
  """
  # i是字符串的索引，text_len是长度
  i, text_len = 0, len(text)
  while True:
    # 循环遍历字符串
    # 到结尾结束，遇到括号提供给ver
    # 如果长度大于字符串的索引 并且遍历得到的字符串不在parens里停止循环
    while i < text_len and text[i] not in parens:
      i += 1
    if i >= text_len:
      return
    else:
      yield text[i], i
      i += 1


# 字符是否匹配的验证工作
def ver():
  for pr, i in for_text(text):
    if pr in left_parens:
      st.push_stack((pr, i))  # 左括号入栈
    elif st.is_empty_stack() or st.pop_stack()[0] != opposite_dict[pr]:
      # 栈里是空值或者栈里抛出的括号不在字典对应的值中
      print("没匹配%d的位置%s" % (i, pr))
      # for 循环正常结束
      break
    else:
      if st.is_empty_stack():
        print("成了")
      else:
        p = st.pop_stack()
        print("没匹配%d的位置%s" % (p[1], p[0]))


text = "dsfadsfa{d(sfa)dfa[dsf]}asdf"
# for pr, i in for_text(text):
#   print(pr, i)

ver()