带有 pop() 方法的自定义类未返回正确的新列表长度

如何解决带有 pop() 方法的自定义类未返回正确的新列表长度

我在 Python 中有一个自定义类，它的行为应该像 Stack。出于某种原因，当我试图遍历一棵树并向其添加节点时，每次我从列表中弹出它似乎都没有改变它的大小。

代码在打印语句处无限循环中断，但我不知道为什么。 Pop() 应该减少项目的数量，但 len(self.items) 每次循环都会返回 3 或 4。

类定义：

import collections



class Stack:
    def __init__(self,items=[]):
        self.items = items
        self.idx = 0

    def __iter__(self):
        return self
    def __next__(self):
        self.idx += 1
        try:
            return self.items[0-self.idx]
        except IndexError:
            self.idx = 0
            raise stopiteration


    # isEmpty() - returns True if stack is empty and false otherwise
    def isEmpty(self):
        if self.items:
            return False
        return True
    # push() - Insert item at the top of the stack
    def push(self,item):
        self.items.append(item)
        return

    # pop() - Remove and return element from top of the stack,# provided it is not empty
    def pop(self):
        return self.items.pop()

    # also kNown as peek() - return top element from stack without removing,#
    def top(self):
        return self.items[-1]

class Node():
    def __init__(self,value=None):
        self.value = value
        self.left = None
        self.right = None

class Tree:
    def __init__(self,array):
        self.root = None
        self.items = []
        self.size = 0

        if array is not None:
            # check if input array is an actual sequence or scalar
            '''
            Items here are unchanged,only converts to Node in insert() function
            '''
            if isinstance(array,collections.abc.Sequence):
                for item in array:
                    self.insert(item)
                    self.size = self.size +1
            # if input is a single item
            else:
                self.insert(item)
                self.size = self.size +1

    # insert() - add element to corresponding location,then shuffle
    #
    def root(self):
        return self.root

    # returns parent of node v,# error occurs if v is root
    def parent(v):
        if v == self.items[0]:
            raise ValueError("ADT Tree - Parent can't be root (use root() instead)",e)
        return

    # returns an iterator to enumerate the children of node v
    def children(self,v):
        return
    # test wheter node v is internal
    def isInternal(self,v):
        if v.left is not None or v.right is not None:
            return True
        return False
    #test whether node v is external (i.e. leaf)
    def isExternal(self,v):
        return not self.isInternal(v)
    # test wheter node v is root
    def isRoot(v):
        return v == self.items[0]


# inherit Tree parent class
# ADT.BinaryTree(array)
# insert(),inorder(node),preOrder(node),postorder(node)
class BinaryTree(Tree):
    # inherit Tree parent class
    def __init__(self,array=tuple()):
        # inherit Tree methods EXCEPT init populating items
        super().__init__(None)

        # list for outputting pre/post/in order  traversals
        self.list = list()
        self.count = 0
        for item in array:
            self.insert(item)


    # test wheter node v is internal
    def isInternal(self,v):
        if v.left or v.right:
            return True
        else:
            return False
        return
    #test whether node v is external (i.e. leaf)
    def isExternal(self,v):
        if v.left or v.right:
            return False
        else:
            return True
        return




    # public
    def insert(self,value):
        self.root = self.insertRecur(self.root,value)
        self.count += 1

    # private recursive
    def insertRecur(self,current,value):
        # base case
        if (current is None):
            return Node(value)
        # traverse left
        if (value < current.value):
            current.left = self.insertRecur(current.left,value)

        # traverse right
        elif (value > current.value):
            current.right = self.insertRecur(current.right,value)

        # if current has same value as node,ignore value as a duplicate
        return current


    # accepts a node,returns a list of elements in subtree rooted at node In-order
    # L node R
    def inorder(self,node):
        self.list = list()
        self._inorder(node)
        return self.list

    # accepts a node,returns a list of elements in subtree rooted at node Pre-order
    # node L R
    def preOrder(self,node):
        self.list = list()
        self._preOrder(node)
        return self.list
    # accepts a node,returns a list of elements in subtree rooted at node Post-order
    # L R node
    def postorder(self,node):
        self.list = list()
        self._postorder(node)
        return self.list


    # L root R
    # prints current node after traversing left children AND before traversing right
    def _inorder(self,node):
        if node is not None:
            self._inorder(node.left)
            self.list.append(node)
            #print("{}".format(node.value),end=" ")
            self._inorder(node.right)
        return

    # root L R
    def _preOrder(self,node):
        if node is not None:
            self.list.append(node)
            #print("{}".format(node.value),end=" ")
            self._preOrder(node.left)
            self._preOrder(node.right)
        return

    # R root L
    def _postorder(self,node):
        if node is not None:
            self._postorder(node.right)
            self.list.append(node)
            #print("{}".format(node.value),end=" ")
            self._postorder(node.left)
        return

主代码 （问题围绕打印语句）

def main():
    test = (4,5,8,9,2,1,10,3,6,7)
    newtree = BinaryTree(test)

    stk_c = Stack()
    stk_f = Stack()
    node = newtree.root
    prev = None



    while node or not stk_c.isEmpty():
        # if node has already been travelled,# traverse its left child
        if node is not None:
            stk_c.push(node)
            node = node.left

        elif node is None:
            node = stk_c.top()
            if node.right is None or node.right == prev:
                print("before popping stk_c",len(stk_c.items))
                stk_f.push(node.value)
                stk_c.pop()
                print("after popping stk_c",len(stk_c.items))
                prev=node
                node = None
            else:
                node = node.right


if __name__ == "__main__":
    main()