判断一颗二叉树是否是二叉搜索树 不通过递归实现

class Node:
    '''
    节点模型
    建树算法
    '''

    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

    def getChildNodeList(self, nodeList):
        '''
        获取下一层的节点集合
        :param nodeList:
        :return:
        '''
        childNodeList = []
        for i in nodeList:
            # 注意python-append是顺序插入的
            if i.left != None:
                childNodeList.append(i.left)
            if i.right != None:
                childNodeList.append(i.right)
        return childNodeList

    def isBSTNodeList(self, nodeList):
        '''
        判断每一层的各个节点值和上下层父与子节点的值的关系
        问题转化为获取每一层节点的集合
        :param nodeList:
        :return:
        '''

        if len(nodeList) == 0:
            return True
        valList, childValList = [], []
        for i in nodeList:
            valList.append(i.val)
            if i.left != None:
                childValList.append(i.left.val)
                if i.left.val > i.val:
                    return False
            if i.right != None:
                childValList.append(i.right.val)
                if i.right.val < i.val:
                    return False
        if not isAscList(valList):
            return False
        if not isAscList(childValList):
            return False
        return True

    def isBSTNotByRecursion(self):
        '''
        不使用递归，使用迭代
        须且只须只要每一层的节点数值和上下层父与子节点的值的关系满足条件
        :return:
        '''
        currentNodeList = [self]
        # 迭代
        i = 0
        while currentNodeList != []:
            if self.isBSTNodeList(currentNodeList):
                currentNodeList = self.getChildNodeList(currentNodeList)
                i += 1
                print(i)
            else:
                return False
        return True


def isAscList(l):
    '''
    判断一个数组是否是有小到大排列
    可以使用多种排序算法
    :param l:数组
    :return:
    '''
    return l == sorted(l, reverse=False)


class BST(Node):
    '''
    二叉搜索树继承二叉树
    '''

    def insert(self, val):
        '''
        插入元素的算法
        :param val:插入值
        :return:
        '''
        currentNode = self
        nd = Node(val)
        while currentNode.left != None or currentNode.right != None:
            # 走向左子树
            if currentNode.val >= val:
                if currentNode.left == None:
                    currentNode.left = nd
                    return
                # 左子树的的左子树
                if currentNode.left.val < val:
                    # 插入左子树
                    tmp = currentNode.left
                    currentNode.left = nd
                    nd.left = tmp
                    return
                else:
                    # 走向左子树的左子树
                    currentNode = currentNode.left
            else:
                # 走向右子树
                if currentNode.right == None:
                    currentNode.right = nd
                    return
                if currentNode.right.val > val:
                    tmp = currentNode.right
                    currentNode.right = nd
                    nd.right = tmp
                    return
                else:
                    currentNode = currentNode.right
        if val <= currentNode.val:
            currentNode.left = nd
        else:
            currentNode.right = nd


if __name__ == "__main__":
    n = BST(43)
    l = [23, 34, 5, -5, 5, 5, 45, 454, 456, -8, -8, -6]
    pass_ = [n.insert(i) for i in l]
    print(n.isBSTNotByRecursion())

    n = Node(43)
    n.left = Node(5)
    n.left.right = Node(6)
    print(n.isBSTNotByRecursion())