python小练习10 -- 顺序栈和链栈的实现及其应用

class StackException(Exception):
    pass


class ExpressionExcepton(Exception):
    pass


class Node:
    def __init__(self, value, node=None):
        self.value = value
        self.next = node

    @property
    def value(self):
        return self.__value

    @value.setter
    def value(self, value):
        if isinstance(value, int):
            self.__value = value
        else:
            raise ValueError("value should be an instance of int")

    @property
    def next(self):
        return self.__next

    @next.setter
    def next(self, node):
        if isinstance(node, Node) or node is None:
            self.__next = node
        else:
            raise ValueError("node should be an instance of Node")


class LStack:
    """
    链栈实现
    """
    def __init__(self):
        self.__top = None

    def push(self, value):
        node = Node(value)
        if self.__top is None:
            self.__top = node
        else:
            node.next = self.__top
            self.__top = node

    def pop(self):
        if self.__top is None:
            raise StackException
        else:
            node = self.__top
            self.__top = node.next
            return node.value

    def top(self):
        if self.__top is None:
            raise StackException
        else:
            return self.__top.value

    def is_empty(self):
        if self.__top is None:
            return True
        else:
            return False

    def info(self):
        node = self.__top
        while node is not None:
            print(node.value, end=" ")
            node = node.next
        print()


class SStack:
    """
    实现顺序栈类：方法push pop is_empty top
    """
    __slots__ = ["__stack"]

    def __init__(self):
        self.__stack = []

    def push(self, value):
        """
        将传入的值压栈
        :param value: 传入值
        :return: 无
        """
        self.__stack.append(value)

    def is_empty(self):
        """
        判断栈是否为空
        :return: True/False
        """
        if len(self.__stack) > 0:
            return False
        else:
            return True

    def pop(self):
        """
        弹出栈顶元素
        :return: 栈顶元素
        """
        if self.is_empty():
            raise StackException
        else:
            return self.__stack.pop()

    def top(self):
        """
        查看栈顶元素
        :return: 返回栈顶元素
        """
        if self.is_empty():
            raise StackException
        else:
            return self.__stack[- 1]

    def info(self):
        """
        控制台输出所有栈中元素
        :return: 无
        """
        for item in self.__stack:
            print(item, end=" ")
        print()


class RPoland:
    """顺序栈应用：逆波兰表达式"""
    operators = ["+", "-", "*", "/"]

    def __init__(self):
        self.__stack = SStack()

    def operate(self, expression):
        """
        对表达式进行解析计算：1 2 + 4 * p 解析成：（1+2）*4
        :param expression: 逆波兰表达式
        :return: 返回计算结果
        """
        vars = expression.split(" ")
        if vars[-1] != "p":
            raise ExpressionExcepton
        else:
            for item in vars[0:-1]:
                if item in RPoland.operators:
                    var2 = self.__stack.pop()
                    var1 = self.__stack.pop()
                    val = self.__calc(var1, var2, item)
                    self.__stack.push(val)
                else:
                    try:
                        val = float(item)
                        self.__stack.push(val)
                    except:
                        continue
            return self.__stack.top()

    def __calc(self, var1, var2, operator):
        if operator == "+":
            return var1 + var2
        elif operator == "-":
            return var1 - var2
        elif operator == "*":
            return var1 * var2
        else:
            return var1 / var2


if __name__ == "__main__":
    print("============测试顺序栈================")
    stack = SStack()
    print("栈是否为空：", stack.is_empty())

    for item in [1, 2, 3, 4, 5]:
        stack.push(item)

    print("栈中所有元素：")
    stack.info()

    while not stack.is_empty():
        value = stack.pop()
        print(value, end=" ")
    print()

    print("栈是否为空：", stack.is_empty())
    print("============测试顺序栈结束================")
    print("============测试逆波兰表达式：==============")
    express = RPoland()
    print(express.operate("1 2 + 3 * 1 - p"))
    print(express.operate("2 / p"))
    print("============测试逆波兰表达式结束==============")
    print("=============测试链栈=======================")
    stack = LStack()
    print("入栈")
    for item in [1, 2, 3, 4, 5]:
        print("入栈：", item)
        stack.push(item)
    print("入栈完成")

    print("栈中所有元素：")
    stack.info()
    print("出栈")
    while not stack.is_empty():
        value = stack.pop()
        print(value, end=" ")
    print()
    print("出栈结束")
    print("=============测试链栈结束=======================")