[python栈]栈基础实现

栈是一种只能通过访问一端来实现数据存储与检索的线性数据结构，具有后进先出的特征。

栈的抽象数据类型

一个栈一般会实现以下方法：

• Stack() 构造方法，创建一个空栈，无参数，返回值是空栈

• push(value) 向栈顶压入一个新数据项，需要一个数据项参数，无返回值

• pop() 抛出栈顶数据项，无参数，返回被抛出的数据项，栈本身发生变化

• is_empty() 测试栈是否空栈。不需要参数，返回布尔值

• size() 返回栈内数据项的数目，不需要参数，返回值是整数

• peak() 返回栈顶数据项，但不删除。不需要参数，栈不变

方法一：

python内置的列表list可以当作栈来使用，使用.append和.pop方法可以实现数据压入和弹出。

class Stack:
    def __init__(self):
        self.values = []

    def push(self, value):
        self.values.append(value)

    def pop(self):
        return self.values.pop()

    def is_empty(self):
        return self.size()==0

    def size(self):
        return len(self.values)

    def peak(self):
        return self.values[self.size()-1]


if __name__ == '__main__':
    stack = Stack()
    print(stack.is_empty())
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(stack.values)
    stack.pop()
    print(stack.values)

方法二：

采用类似链表的结构，先定义结点类，再定义stack类。

定义一个结点：

定义一个栈：

注意栈顶和栈尾的位置，压入数据时，是从栈尾逐渐走向栈顶。图中是依次压入4，5，6数据时栈的情况。

程序实现：

# 定义一个结点
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None


# 定义栈
class Stack:
    def __init__(self):
        self.top = None

    def push(self, value):
        node = Node(value)
        node.next = self.top
        self.top = node

    def pop(self):
        node = self.top
        if node is None:
            raise Exception("This is an empty stack")
        self.top = node.next
        return node.value

    def peak(self):
        node = self.top
        if node is None:
            raise Exception("This is an empty stack")
        return node.value

    def is_empty(self):
        return not self.top

    def size(self):
        node = self.top
        count = 0
        if node is None:
            raise Exception("This is an empty stack")
        while node is not None:
            count += 1
            node = node.next
        return count


if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(stack.size())
    print(stack.pop())
    print(stack.pop())
    print(stack.size())

top指向栈顶的Node，next指向下一个Node，若没有下一个Node，则指向None。

栈的应用

十进制转二进制 是一个应用堆栈的典型案例。十进制转二进制 采用“除2取余，逆序排列”的方法，如图所示：

借助Stack类，可以很方便地实现上述转换算法：

# 定义一个结点
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None


# 定义栈
class Stack:
    def __init__(self):
        self.top = None

    def push(self, value):
        node = Node(value)
        node.next = self.top
        self.top = node

    def pop(self):
        node = self.top
        if node is None:
            raise Exception("This is an empty stack")
        self.top = node.next
        return node.value

    def peak(self):
        node = self.top
        if node is None:
            raise Exception("This is an empty stack")
        return node.value

    def is_empty(self):
        return not self.top

    def size(self):
        node = self.top
        count = 0
        if node is None:
            raise Exception("This is an empty stack")
        while node is not None:
            count += 1
            node = node.next
        return count


def divideby2(dec_number):
    remstack = Stack()

    while dec_number > 0:
        rem = dec_number % 2
        remstack.push(rem)
        dec_number = dec_number // 2

    binstring = ""
    while not remstack.is_empty():
        binstring = binstring + str(remstack.pop())

    return binstring


if __name__ == '__main__':
    print(divideby2(50))