栈

定义栈类

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/12'
"""


class pythonStack:
    def __init__(self):
        # 使用list作为栈的底层实现
        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)

字符匹配 中缀式转换后缀式 后缀式求值

# python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'wlc'
__mtime__ = '2017/10/12'
"""

from  dataStructure.dS import pythonStack

# 类实例化
stack = pythonStack.pythonStack()
"""
push 进栈
pop 出栈
isEmpty 是否为空栈
items 栈元素
size 栈大小
peek 返回栈顶

"""


def parChecker(parString):
    """
    :program 括号匹配()
    :param parString: 括号串
    :return:True or False
    """
    flag = True
    s = pythonStack.pythonStack()
    index = 0
    while (index < len(parString)):
        str = parString[index]
        if (str == "("):
            s.push(str)
        else:
            if (s.isEmpty()):
                flag = False
            else:
                s.pop()
        index = index + 1
    if flag and s.isEmpty():
        return True
    else:
        return False


def parCheckerAll(parString):
    """
    :program 符号匹配（{[]})
    :param parString: 括号串
    :return:True or False
    """
    flag = True
    s = pythonStack.pythonStack()
    index = 0
    while (index < len(parString)):
        str = parString[index]
        if (str in "([{"):
            s.push(str)
        else:
            if (s.isEmpty()):
                flag = False
            else:
                par = s.pop()
                if not match(par, str):
                    flag = False
        index = index + 1
    if flag and s.isEmpty():
        return True
    else:
        return False


def match(par, str):
    """
    :program: pop 出的字符是否与}]) 匹配
    :param par:([{
    :param str:)]}
    :return:
    """
    pars = "([{"
    strs = ")]}"
    return pars.index(par) == strs.index(str)


def divideBy2(num):
    """
    :program:十进制二进制
    :param num: 十进制
    :return: 二进制
    """
    s = pythonStack.pythonStack()
    while num > 0:
        push = num % 2
        s.push(push)
        num = num // 2
    binString = ""
    while not s.isEmpty():
        binString = binString + str(s.pop())
    return binString


def divideByBase(num, base):
    """
    :program:十进制转换其他进制2-16
    :param num: 十进制
    :param base: 2-16进制
    :return: 2-16进制
    """
    s = pythonStack.pythonStack()
    jinzhi = "0123456789ABCDEF"
    while num > 0:
        push = num % base
        s.push(push)
        num = num // base
    binString = ""
    while not s.isEmpty():
        binString = binString + jinzhi[s.pop()]
    return binString


def infixToPostfix(func):
    """
    :program:中缀式转后缀式
    :param func: 中缀式（string）
    :return:后缀式（string）
    """
    # 栈用于存储操作符
    s = pythonStack.pythonStack()
    # 列表存储变量数字
    numList = []
    # 将输入的function切割成列表
    funcsList = func.split(" ")
    # 为了比较运算符优先级方便将运算符放到字典对其进行优先级赋值
    opDict = {}
    opDict["*"] = 3
    opDict["/"] = 3
    opDict["+"] = 2
    opDict["-"] = 2
    opDict["("] = 1
    # 循环funcList
    for funcList in funcsList:
        # 如果funcList是变量数字则将其放到numList中
        if funcList in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or funcList in "0123456789" or funcList in "abcdefghijklmnopqrstuvwxyz":
            numList.append(funcList)
        # 如果funclist是(的话 就将其push进入栈
        elif funcList == "(":
            s.push(funcList)
        # 如果等于）则进行pop操作指导弹出（左括号
        elif funcList == ")":
            topFunc = s.pop()
            while topFunc != "(":
                numList.append(topFunc)
                topFunc = s.pop()
        # 如果是运算符则要进行压栈 如果  栈顶  有运算等级大于或者等于该运算符的运算符则要进行pop
        else:
            while (not s.isEmpty()) and opDict[s.peek()] >= opDict[funcList]:
                numList.append(s.pop())
            # 将所有优先级高的运算符pop后进行push操作
            s.push(funcList)
    while not s.isEmpty():
        numList.append(s.pop())
    return " ".join(numList)


def postfixEval(func):
    """
    :program:后缀式计算
    :param func: 后缀式
    :return: 计算结果
    """
    # 初始化一个栈用于存储计算过程中产生的数据
    s = pythonStack.pythonStack()
    # 将func字符串 分割
    funcsList = func.split(" ")
    # 循环list
    for funcList in funcsList:
        # 如果是数字进行压栈
        if funcList in "0123456789":
            s.push(int(funcList))
        else:
            # 栈后进先出一次第一次pop出的是第二个操作数
            op2 = s.pop()
            op1 = s.pop()
            result = doMath(funcList, op1, op2)
            # 将计算结果压栈
            s.push(result)
    return s.pop()


def doMath(op, op1, op2):
    if op == "*":
        return op1 * op2
    elif op == "/":
        return op1 / op2
    elif op == "+":
        return op1 + op2
    else:
        return op1 - op2


if __name__ == '__main__':
    print("判断栈是否为空：" + str(stack.isEmpty()))
    stack.push(5)
    print(stack.items)

    stack.pop()
    print(stack.items)

    stack.push(5)
    print("push一个item 栈大小：" + str(stack.size()))

    stack.push('cat')
    stack.push('dog')
    print(stack.items)

    stack.peek()
    print("使用peek方法已经返回栈顶")
    #######################################################
    strPar = input("请输入括号串()：")
    var = parChecker(strPar)
    print("是否括号匹配：" + str(var))
    #######################################################
    strPar = input("请输入字符串({[]})：")
    var = parCheckerAll(strPar)
    print("是否符号匹配：" + str(var))
    #######################################################
    var = input("请输入十进制数字：")
    print("十进制 %s 转二进制：%s " % (var, divideBy2(10)))
    #######################################################
    var = input("请输入十进制数字：")
    var1 = input("请输入要转换的进制2-16：")
    print("十进制 %s 转 %s 进制：%s " % (var, var1, divideByBase(int(var), int(var1))))
    #######################################################
    var1 = input("请输入要转换成后缀式的中缀式：")
    print("后缀式为：" + infixToPostfix(var1))
    #######################################################
    var1 = input("请输入要计算的后缀式：")
    print("后缀式结果：" + str(postfixEval(var1)))