在Binary搜索树中打印K个最小值

Question

我试图弄清楚如何在二进制搜索树中打印最低的k值。 我无法停止该方法

码：

def kthSmallestBST(node,k, count):
    if node == None or count == k:
        return
    else:
        kthSmallestBST(node.left, k, count)
        count += 1
        print node.data
        kthSmallestBST(node.right, k, count)
        count += 1


kthSmallestBST(BST, 3, 0)

目前我的输出只是按顺序打印了整棵树

Answer 1

对count值的更改不会传播回调用者。 您需要返回新的计数：

def kthSmallestBST(node,k, count):
    if node is None or count >= k:
        return 0
    else:
        count += kthSmallestBST(node.left, k, count)
        if count < k:
            print node.data
            count += 1
        count += kthSmallestBST(node.right, k, count)
        return count

还要注意，您既不需要k也不需要count 。 您可以摆脱count ，减少k而不是递增count ，然后将k与0（而不是对count ）进行比较。 这是您得到的：

def kthSmallestBST(node, k):
    if node is None or k <= 0:
        return 0
    k = kthSmallestBST(node.left, k)
    if k > 0:
        print node.data
        k -= 1
    k = kthSmallestBST(node.right, k)
    return k

Answer 2

这是一个相当“功能性的编程”解决方案，但是一种方法是依次生成（延迟）树中的节点，然后使用itertools取第一个k。

def inorder(tree):
    if not tree: return
    for node in inorder(tree.left): yield node
    yield tree
    for node in inorder(tree.right): yield node

def least(tree, k):
    return itertools.islice(inorder(tree), k)

如果您使用的是Python 3，则可以使用“ yield from”来简化此解决方案。

Answer 3

您需要进行一些更改，以便您知道在递归调用中找到了多少个元素。 让函数返回它发现的元素的数量并加起来。 另外，您还需要检查递归调用与当前节点元素之间的计数。

就像是：

def kthSmallestBST(node, k, count):
    if node == None or count == k:
        return 0
    else:
        count += kthSmallestBST(node.left, k, count)
        if(count == k) 
            return count
        print node.data
        count += 1
        count += kthSmallestBST(node.right, k, count)
        return count

Answer 4

import unittest

class BST(object):

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


def get_kth_smallest_keys(node, k): 
    """Return, as a list, `k` smallest keys in a binary search tree rooted at `node`.

    """
    smallest = []
    _get_kth_smallest_keys(node, k, smallest)
    return smallest

def _get_kth_smallest_keys(node, k, smallest):
    """A helper function. Appends nodes to the given list, `smallest`, and stop
    when k reaches 0.

    Returns the number of nodes appended to said list.

    """
    if node is None or k == 0:
        return 0
    # first, recurse left, and we get the number of nodes appended to the list by that call
    nk = _get_kth_smallest_keys(node.left, k, smallest)
    # if that number already reduces our counter to zero, we fail fast, returning that same number
    if k - nk <= 0:
        return nk
    # otherwise, we can still append this node's key to the list
    smallest.append(node.key)
    # then we recurse right, with a counter that is less 1 (our append) and less nk (appended by the left recurse)
    nnk = _get_kth_smallest_keys(node.right, k - 1 - nk, smallest)
    # our return value is the sum of our append (1) and the appends from both recurse calls
    return nk + 1 + nnk 


class BSTTest(unittest.TestCase):

    def test_smallest_keys(self):
        root = BST(10)
        root.left = BST(6)
        root.right = BST(15)
        root.left.right = BST(8)
        root.right.right = BST(20)

        self.assertEquals(get_kth_smallest_keys(root, 0), []) 
        self.assertEquals(get_kth_smallest_keys(root, 1), [6])
        self.assertEquals(get_kth_smallest_keys(root, 3), [6, 8, 10])
        self.assertEquals(get_kth_smallest_keys(root, 5), [6, 8, 10, 15, 20])
        self.assertEquals(get_kth_smallest_keys(root, 6), [6, 8, 10, 15, 20])


if __name__ == '__main__':
    unittest.main()