【栈的抽象数据类型】ADT stack的python实现

栈的抽象数据类型

• 栈Stack：什么是栈？
  • 一种有次序的数据项集合，在栈中，数据项的加入和移除都仅发生在同一端
  • 距离栈底越近的数据项，留在栈中的时间越长，而最新加入的数据项会被最先移除。即后进先出LIFO: Last In First Out
• 栈的特性： 次序反转

栈的操作及操作样例

• 栈的操作
  
• 栈的操作样例
  

Python实现

• 列表的尾端当作栈顶

class Stack:
	def __init__(self):
		self.items = []
	def isEmpty(self):
		return self.items == []
	def push(self, item):
		self.items.append(item)
	def pop(self):
		return self.items.pop()
	def peek(self):
		return self.items[len(self.items)-1]
	def size(self):
		return len(self.items)

• 列表的首端当作栈顶

class Stack:
	def __init__(self):
		self.items = []
	def isEmpty(self):
		return self.items == []
	def push(self, item):
		self.items.insert(0,item)
	def pop(self):
		return self.items.pop(0)
	def peek(self):
		return self.items[0]
	def size(self):
		return len(self.items)

栈的应用：简单括号匹配

• 计算中加入括号是十分常见的，但是括号不是随便加的，括号需要进行匹配。比如“(( ))”是符合规则的，但是"((( ))"就是不符合规则的。

def JudgeBalance(s):
    stack = []
    for i in s:
        if i == "(":
            stack.append(i)
        elif i == ")":
            if len(stack) == 0:
                return False
            else:
                stack.pop()
    if len(stack) == 0:
        return True
    else:
        return False

• 在括号中加入“[]”和“{}”。符合规则的有“{[()]}”，不符合规则的例如“{([ }])”

def JudgeBalance(s):
    matchs = {
    
    '{':'}', '[':']', '(':')'}
    stack = []
    for i in s:
        if i in "([{":
            stack.append(i)
        elif i in ")]}":
            if len(stack) == 0:
                return False
            else:
                top = stack.pop()
                if matchs[top] != i:
                    return False
                
    if len(stack) == 0:
        return True
    else:
        return False

栈的应用：进制转换

• 十进制转为2进制

def divideBy2(number):
	if number == 0:
		return '0'
	res = []
	while number > 0:
		res.append(number % 2)
		number //= 2
	binString = ""
	while len(res) != 0:
		binString = binString + str(res.pop())
	return binString	

• 十进制转化为其它进制

def divideBy2(number, base):
	if number == 0:
		return '0'
	digits = "0123456789ABCDEF"
	res = []
	while number > 0:
		res.append(number % base)
		number //= base
	binString = ""
	while len(res) != 0:
		binString = binString + digits[res.pop()]
	return binString

栈的应用：中缀表达式 转换为 后缀表达式

def infixToPostfix(infixexpr):
    """
    :infixexpr: 中缀表达式字符串，以空格隔开
    :return: 后缀表达式，以空格隔开
    """
    # 记录操作符优先级
    prec = {
    
    }
    prec["*"] = 3
    prec["/"] = 3
    prec["+"] = 2
    prec["-"] = 2
    prec["("] = 1
    opStack = []
    postfixList = []
    tockenlist = infixexpr.split()

    for token in tockenlist:
        if token in "ABCDEFGHIJKLMNOPQRSTUVWSYZ" or token in "0123456789":
            postfixList.append(token)
        elif token == "(":
            opStack.append(token)
        elif token == ")":
            topToken = opStack.pop()
            while topToken != "(":
                postfixList.append(topToken)
                topToken = opStack.pop()
        else:
            while (len(opStack) != 0) and (prec[opStack[-1]] >= prec[token]):
                postfixList.append(opStack.pop())
            opStack.append(token)
    while len(opStack) != 0:
        postfixList.append(opStack.pop())
    return " ".join(postfixList)

参考视频资料：栈的应用：中缀表达式 转换为 后缀表达式
参考视频资料：栈抽象数据类型及python实现