使用链接实现创建堆栈ADT

一个节点类（Node class）。您将使用链接（linked implementation）实现创建堆栈（Stack） ADT。实现是链接的节点。

问题相关代码，请勿粘贴截图

运行结果及报错内容

class Node:

def __init__(self, data, node=None):
    # 初始化这个节点，插入数据，如果有则设置下一个节点
    self.data = data
    self.chain = node

class MyStack:
def init(self, data=None):
# 初始化这个栈，如果存在则存储数据
pass
self.length = 0
self.last = None
if data != None:
self.push(data)

def push(self, data):
    # 将数据添加到栈的开头
    newNode = Node(data)

    if self.last != None:
        newNode.prev = self.last
    self.last = newNode
    self.length = self.length + 1
    pass

def pop(self):
    # 移除栈首元素。
    # 返回栈首元素中的数据，如果栈为空则返回None
    if self.length == 0:
        return None

    data = self.last.data
    self.last = self.last.prev
    self.length = self.length - 1
    return data
    pass


def top(self):
    # 返回开头元素中的数据，但不移除。
    # 如果堆栈为空，则返回 None。
    if self.length == 0:
        return None
    pass

def __len__(self):
    # 返回栈中的元素个数
    return self.length
    pass

def sum_exists(n, p_list):
# 如果 n 可以从重复的 p_list 中形成，则返回 True
# 任意次数。
pass

我想要达到的结果

改了下算法看看行不行

class Node:
    def __init__(self, data, node=None):
        # 初始化这个节点，插入数据，如果有则设置下一个节点
        self.data = data
        self.chain = node

class MyStack:
    def __init__(self, data=None):
        # 初始化这个栈，如果存在则存储数据
        pass
        self.length = 0
        self.last = None
        if data != None:
            self.push(data)

    def push(self, data):
        # 将数据添加到栈的开头
        newNode = Node(data)

        if self.last != None:
            newNode.chain = self.last  #应该是chain
        self.last = newNode
        self.length = self.length + 1
        pass

    def pop(self):
        # 移除栈首元素。
        # 返回栈首元素中的数据，如果栈为空则返回None
        if self.length == 0:
            return None

        data = self.last.data
        self.last = self.last.chain  #应该是chain
        self.length = self.length - 1
        return data
        pass


    def top(self):
        # 返回开头元素中的数据，但不移除。
        # 如果堆栈为空，则返回 None。
        if self.length == 0:
            return None
        return self.last.data   #加上

    def __len__(self):
        # 返回栈中的元素个数
        return self.length
        pass

def sum_exists(n, p_list):
    # 如果 n 可以从重复的 p_list 中形成，则返回 True
    # 任意次数。
    li = sorted(p_list,reverse=True)
    l = len(li)
    st = MyStack() #定义空栈
    st.push([0,0]) #给栈赋初值0
    while len(st)>0:  #处理栈，当栈为空时结束循环
        d,i = st.pop()  #出栈
        if (n-d)%li[i] == 0:
            return True
        if i < l-1:
            while d < n:
                st.push([d, i+1]) #入栈
                d += li[i]
    return False

if __name__ == "__main__":
    print(sum_exists(17, [2,3,5]))
    print(sum_exists(7, [3,5]))
    print(sum_exists(107, [2,3,37]))
    print(sum_exists(43, [3,29]))
    print(sum_exists(146, [17,29,37]))

import copy
def getStudentNumber():
    # This method must return a string of your student number
    # If the number does not match your actual student number
    # You will not get the marks for this lab
    return "012345678"


class Node:
    def __init__(self, data, node=None):
        # 初始化这个节点，插入数据，如果有则设置下一个节点
        self.data = data
        self.chain = node
 
class MyStack:
    def __init__(self, data=None):
        # 初始化这个栈，如果存在则存储数据
        self.length = 0
        self.last = None
        self.sum = 0
        if data != None:
            self.push(data)
 
    def push(self, data):
        # 将数据添加到栈的开头
        newNode = Node(data)
        if self.last != None:
            newNode.chain = self.last
        self.last = newNode
        self.length = self.length + 1
        self.sum += data
        return self
 
    def pop(self):
        # 移除栈首元素。
        # 返回栈首元素中的数据，如果栈为空则返回None
        if self.length == 0:
            return None
        else:
            data = self.last.data
            if self.last.chain!=None:
                self.last = self.last.chain
                self.length = self.length - 1
            else:
                self.length = 0
                self.last = None
            self.sum -= data
            return data  
 
    def top(self):
        # 返回开头元素中的数据，但不移除。
        # 如果堆栈为空，则返回 None。
        if self.length == 0:
            return None
        else:
            return self.last.data

    def __len__(self):
        # 返回栈中的元素个数
        return self.length
 
def sum_exists(n, p_list):
    if n==0:
        return True
    st = MyStack()
    def fun(st,i=0):
        # print(st.sum, i)
        if (n-st.sum)<min(p_list) or i>=len(p_list):
            return False
        else:
            for p in p_list:
                if (n-st.sum)%p==0:
                    return True
            else:
                st1 = copy.copy(st)
                return fun(st.push(p_list[i]),i) or fun(st1,i+1)       
    return fun(st)

这篇文章：数据结构：数组ADT 也许能够解决你的问题，你可以看下