时间戳

首页 > 解决方案 > 从类成员函数返回一个有效的 self 对象在调用者方法中被评估为 None

python - 从类成员函数返回一个有效的 self 对象在调用者方法中被评估为 None

问题描述

''' 使用 BST 的简单地图 ADT 实现 '''

#! /usr/bin/env python3

import os

class TreeNode:
    def __init__(self, key, data, left, right, parent):
        self.key = key
        self.value = data
        self.leftchild = left
        self.rightchild = right
        self.parent = parent

    def insertnode(self, key, value):
        if key <= self.key:
            #left child
            if self.leftchild is not None:
                self.leftchild.insertnode(key, value)
            else:
                self.leftchild = TreeNode(key=key, data=value, left=None, right=None, parent=self)
        else:
            if self.rightchild is not None:
                self.rightchild.insertnode(key, value)
            else:
                self.rightchild = TreeNode(key=key, data=value, left=None, right=None, parent=self)

    def displaynode(self):
        if self.key is not None:
            print(self.key, ":", self.value)
            if self.leftchild is not None:
                self.leftchild.displaynode()
            if self.rightchild is not None:
                self.rightchild.displaynode()

    def search(self, key):
        if self is None:
            return None
        elif key == self.key:
            return self
        elif key < self.key:
            self.leftchild.search(key)
        else:
            self.rightchild.search(key)

    def deletekey(self, key):
        keyNode = self.search(key)
        print(keyNode)
        if keyNode is None:
            raise KeyError('Key not found in the tree.')
        else:
            if keyNode.leftchild is None and keyNode.rightchild is None:
                keyNode = None
            elif keyNode.leftchild is not None and keyNode.rightchild is not None:
                if keyNode.parent is None:
                    self.root = keyNode.leftchild
                else:
                    keyNode.rightchild.parent = keyNode.leftchild
                    keyNode.parent.leftchild = keyNode.leftchild
                keyNode = None
            elif keyNode.leftchild is not None:
                keyNode.parent.leftchild = keyNode.leftchild
                keyNode = None
            elif keyNode.rightchild is not None:
                keyNode.parent.leftchild = keyNode.rightchild
                keyNode = None
        return True


class binaryTree():
    def __init__(self):
        self.root = None
        self.size = 0

    def length(self):
        return self.size

    def __len__(self):
        return self.size

    def insert(self, key, value):
        if self.root is None:
            self.root = TreeNode(key=key, data=value, left=None, right=None, parent=self)
            self.size = self.size + 1
        else:
            self.root.insertnode(key, value)
            self.size = self.size + 1

    def display(self):
        if self.root is None:
            return None
        else:
            #currentNode = self.root
            self.root.displaynode()

    def __setitem__(self, key, value):
        self.root.insertnode(key, value)
        self.size = self.size + 1

    def __contains__(self, item):
        if self.root.search(item) is not None:
            return True
        else:
            return False

    def find(self, key):
        if self.root.search(key) is not None:
            return True
        else:
            return False

    def __delitem__(self, key):
        if self.root.deletekey(key, self.root):
            self.size = self.size - 1


if __name__ == "__main__":
    tree = binaryTree()
    tree.insert(100, 'a')
    tree.insert(50, 'b')
    tree.insert(200, 'c')
    #tree.insert(25, 'd')
    tree[25] = 'd'
    print(tree.size)
    tree.display()
    if 50 in tree:
        print(f'{50} found')
    else:
        print(f'{50} not found')

    print(tree.find(50))
    tr = TreeNode(key = 100, data='a', left=None, right=None parent=None)
    print(tr.search(100))
    #del tree[50]
    #tree.display()

我正在通过使用contains覆盖“in”来在树中查找键 50，并且该键在树中，它从 TreeNode 类的搜索方法中返回“self”对象。但是，当它在二叉树类中的contains或 find() 中求值时，它始终为 None。不知道我在这里缺少什么。

标签： pythonoop

解决方案

您的问题是您没有在TreeNode.search方法中返回递归搜索的值，因此最终返回值将始终为 None，因为这些条件分支不会返回任何值（除非您要查找的键属于到您搜索的第一个节点）：

def search(self, key):
        if self is None:
            return None
        elif key == self.key:
            return self
        elif key < self.key:
            return self.leftchild.search(key) # need to return this value
        else:
            return self.rightchild.search(key) # need to return this value

推荐阅读