基于Python的数据结构实验——顺序栈与链栈建立与操作（附详细代码和注释）

1、创建名为 prac03_01.py 的文件，在其中编写一个顺序栈的类，该类必须包含顺序栈 的定义及基本操作，并通过以下步骤测试基本操作的实现是否正确，给出运行结果。

(1)初始化一个顺序栈 SequenceStack。

(2)判断栈是否为空。

(3)将元素 1，3，5 依次进栈。

(4)遍历栈内所有元素。

(5)获取栈顶元素。

(6)获取栈的长度。

(7)将栈中元素依次出栈并输出。

(8)判断栈是否为空。

class SequenceStack(object):  # 新建顺序栈类
    def __init__(self):  #初始化顺序栈
        self.maxstorage = 10  # 初始化栈的容量
        self.s = []
        for i in range(0, self.maxstorage):
            self.s.append(None)  # 给栈的所有值赋为None
        self.top = -1  # 栈顶
    
    def EmptyJudgement(self):  # 判断是否为空函数
        if self.top == -1:  # 如果栈顶还是-1。就相当于未写入数据
            print("栈为空。")
        else:
            print("栈不为空。")
    
    def Append(self):  # 数据入栈函数
        while True:  # 循环写入
            if self.top < self.maxstorage:  # 如果没有超出存储容量限制
                data = input("请输入入栈元素，一次输入一个，输入“终止”以结束输入：")  # 输入
                if data != "终止":
                    self.top = self.top + 1  # 栈顶上移
                    self.s[self.top] = data  # 替换写入数据
                    print("成功插入该栈的第%d个元素%s。" % (self.top + 1, data))  # 输入提示
                else:
                    break  # 终止循环
            else:
                print("栈满，无法插入数据。")  # 栈满，提示并终止循环
                break
    
    def SelectAll(self):  # 遍历查找函数
        if self.top == -1:
            print("栈为空。")  # 空栈判断
        else:
            for i in range(0, self.top + 1):
                print(self.s[i], end="  ")  # 循环打印出栈中的数据
    
    def SelectTop(self):  # 查询栈顶元素
        if self.top == -1:
            print("栈为空。")
        else:
            print("栈顶元素为：%s" % (self.s[self.top]))  # 打印栈顶元素
    
    def Length(self):
        print("栈的长度为：%d" % (self.top + 1))  # 就是返回栈顶，再加个1
        
    def Delete(self):  # 出栈函数
        if self.top == -1:
            print("栈为空。")
        else:
            while self.top != -1:  # 如果不是-1（空栈）
                print("当前出栈元素为：%s" % self.s[self.top])  # 打印
                self.s[self.top] = None  # 删除
                self.top = self.top - 1  # 删除后栈顶下移
            print("已全部出栈。")
            
    def choice(self):
        self.__init__()
        while True:
            info = input("请选择操作（数据入栈，数据出栈，查找全部元素，查找栈顶元素，栈长度，栈是否非空）或输入“终止”以结束：")
            if info == "数据入栈":
                self.Append()
            elif info == "数据出栈":
                self.Delete()
            elif info == "查找全部元素":
                self.SelectAll()
            elif info == "查找栈顶元素":
                self.SelectTop()
            elif info == "栈长度":
                self.Length()
            elif info == "栈是否非空":
                self.EmptyJudgement()
            elif info == "终止":
                break
            else:
                print("无效指令")
                
if __name__ == "__main__":
    demo = SequenceStack()
    demo.choice()

2、创建名为 prac03_02.py 的文件，在其中编写结点的类和链式栈的类，后者必须包含 链式栈的定义及基本操作，并通过以下步骤测试基本操作的实现是否正确，给出运行结果。

(1)初始化一个链栈 LinkStack。

(2)判断栈是否为空。

(3)将元素 2，4，6 依次进栈。

(4)获取栈顶元素。

(5)将栈中元素依次出栈并输出。 

class Node(object):  # 定义节点类
    def __init__(self, data):  # 包含data和next的节点
        self.data = data
        self.next = None

class LinkedStack(object):
    def __init__(self):
        self.head = Node(None)  # 初始化头结点，顺便出现了链表的雏形
    
    def EmptyJudgement(self):
        if self.head.next == None:
            return True
        else:
            return False
    
    def Append(self):
        cnode = self.head
        while cnode.next != None:
            cnode = cnode.next
        counter = self.Length()
        while True:
            data = input("请输入入栈元素，一次输入一个，输入“终止”以结束输入：")
            if data != "终止":
                if counter != 9:  # 栈满判定（满栈为10个元素）
                    node = Node(data)  # 将输入的值设置为节点
                    cnode.next = node  # 将节点接入链表
                    cnode = cnode.next  # 索引后移
                    counter = counter + 1  # 计数+1
                else:
                    print("栈满，无法插入数据。")
                    break
                print("成功插入该栈的第%d个元素%s。" % (counter, data))
            else:
                break
                    
    def Length(self):
        cnode = self.head
        counter = 0
        while cnode.next != None:  # 循环移动指针计数
            cnode = cnode.next
            counter = counter + 1
        return counter
    
    def SelectTop(self):
        if self.Length() != 0:
            cnode = self.head
            while cnode.next != None:  #循环移动指针计数
                cnode = cnode.next
            print("栈顶元素为：%s" % cnode.data)
        else:
            print("栈为空。")
            
    def Delete(self):
        while True:  # 循环以删除
            cnode = self.head
            if self.Length() != 0:
                while cnode.next.next != None:  # 循环到最后一个有数据节点的前一个节点
                    cnode = cnode.next
                pnode = cnode  # 设为p节点
                cnode = cnode.next  # 再走一次将cnode赋值为要删除的那个接地那
                print("当前出栈元素为：%s" % cnode.data)
                pnode.next = cnode.next  # 连接跳过要删除的那个节点
                del cnode  # delete一下
            else:
                print("栈为空。")
                break
    
    def choice(self):
        self.__init__()
        while True:
            info = input("请选择操作（数据入栈，数据出栈，查找栈顶元素，栈长度，栈是否非空）或输入“终止”以结束：")
            if info == "数据入栈":
                self.Append()
            elif info == "数据出栈":
                self.Delete()
            elif info == "查找栈顶元素":
                self.SelectTop()
            elif info == "栈长度":
                a = self.Length()
                print("栈长度为%d。" % a)
            elif info == "栈是否非空":
                if self.EmptyJudgement():
                    print("栈为空。")
                else:
                    print("栈不为空。")
            elif info == "终止":
                break
            else:
                print("无效指令")
                
if __name__ == "__main__":
    demo = LinkedStack()
    demo.choice()