在 self 的右侧计算更大的元素

Question

下面给出的这个问题让我发疯。如果有人可以提供帮助，请。

“给定一个包含 'n' 个元素的数组 Num，返回一个长度为 'n' 的数组 A，其中 A[i] 在初始数组的右侧包含大于 Num[i] 的元素数”

我看到了一个 SO 答案 here，但它包含 O(n^2) 的解决方案。我需要 O(nlogn) 的解决方案。

我有“计算自身左侧的较小元素”的解决方案。但是修改它并没有给我所需的解决方案（请参阅下面的代码）。

任何帮助表示赞赏:)

class BinarySearchTreeNode(object):
   def __init__(self, val):
    self.val = val
    self.left = None
    self.right = None
    self.count = 1
    self.leftTreeSize = 0

class BinarySearchTree(object):
   def __init__(self):
    self.root = None
  
   def insert(self, val, root):
    if not root:
        self.root = BinarySearchTreeNode(val)
        return 0

    if val == root.val:
        root.count += 1
        return root.leftTreeSize

    if val < root.val:
        root.leftTreeSize += 1

        if not root.left:
            root.left = BinarySearchTreeNode(val)
            return 0
        return self.insert(val, root.left)

    if not root.right:
        root.right = BinarySearchTreeNode(val)
        return root.count + root.leftTreeSize

    return root.count + root.leftTreeSize + self.insert(val, root.right)

class Solution(object):
  def countSmaller(self, nums):
    
    tree = BinarySearchTree()
    return [
        tree.insert(nums[i], tree.root)
        for i in range(len(nums) - 1, -1, -1)
    ][::-1]

print(Solution().countSmaller(nums = [1, 4, 2, 7]))

例子：

给定数组 [10, 7, 2, 6, 5]

那么从小到右的count数组是[4, 3, 0, 1, 0]

大于左计数的数组为 [0, 1, 2, 2, 3]

希望这会有所帮助...

Answer 1

我不知道这是否是您正在寻找的解决方案，因为我假设您希望我修复您的代码，但可以这样处理：

num = [10, 7, 2, 6, 5]

mergeSort(num) 或 heapSort(num)。我不知道python是否内置了这些，或者您是否需要自己实现。但是mergeSort/heapSort吧，它的最差复杂度是O(nlog(n)。

sortedNum = [2,5,6,7,10]

answer=[ ]

for every number in Num: 
    binarySearch number in sortedNum and return its position
    answer.appened(position)
    delete item from sortedNum at position.

for循环本身的复杂度为O(n)，循环内的二分查找复杂度为log(n)。所以这个函数的复杂度为 O(n log(n))，因为追加和删除需要 O(1)

这意味着排序+伪编码函数的总复杂度为O(2nlog(n)) = O(nlog(n))。

编辑：因为我弄错了，你想在 self 的左边计算更大的元素。

这里不需要排序！

num = [10,7,2,6,5]

排序编号 = [ ]

答案 = [ ]

for every number in Num:
    position = binarySearch number in sortedNum to which numbers its inbetween. 
    insert number into that position into sortedNum
    answer.append(len(num)-position)

Answer 2

class Node(object):
def __init__(self, val):
    self.val = val
    self.left = None
    self.right = None
    self.count = 1
    self.rightTreeSize = 0
    self.leftTreeSize = 0

class BinarySearchTree(object):
def __init__(self):
    self.root = None

def insert(self, val, root):
    if not root:
        self.root = Node(val)
        return 0

    if val == root.val:
        root.count += 1
        return root.rightTreeSize

    if val > root.val:
        root.rightTreeSize += 1

        if not root.right:
            root.right = Node(val)
            return 0
        return self.insert(val, root.right)

    if not root.left:
        root.left = Node(val)
        return root.count + root.rightTreeSize

    return root.count + root.rightTreeSize + self.insert(val, root.left)


class BinarySearchTree1(object):
def __init__(self):
    self.root = None

def insert(self, val, root):
    if not root:
        self.root = Node(val)
        return 0

    if val == root.val:
        root.count += 1
        return root.leftTreeSize

    if val < root.val:
        root.leftTreeSize += 1

        if not root.left:
            root.left = Node(val)
            return 0
        return self.insert(val, root.left)

    if not root.right:
        root.right = Node(val)
        return root.count + root.leftTreeSize

    return root.count + root.leftTreeSize + self.insert(val, root.right)



class Solution(object):
def countGreater(self):
    nums = [10, 7, 2, 6, 5]
    tree = BinarySearchTree()
    print([tree.insert(nums[i], tree.root) for i in range(0, len(nums))])

def countSmaller(self):
    nums = [10, 7, 2, 6, 5]        
    tree1 = BinarySearchTree1()
    print([tree1.insert(nums[i], tree1.root) for i in range(len(nums) - 1, -1, -1)][::-1])


Solution().countSmaller()
Solution().countGreater()

抱歉缩进问题无法调整markdown编辑器中的所有行。

以上代码返回“自身右侧较小元素的数量”和“自身左侧较大元素的数量”