Question

我想找到一种最快的方法来查找比数组中每个元素更小/更大的元素数。

例如：数组是[5,6,8,2,4]。考虑第一个元素，没有比它小的元素是2。

我能做的最好的事情就是将每个元素与其余的数组元素进行比较，但是对于条目数大约为10 ^ 5的大型数组需要很长时间。

我的代码：

for(i=0;i<n;i++)
{
    count=0;
    for(j=0;j<n;j++)
    {
        if( i!=j && (ar[i]>ar[j]) )
        {
            count++;
        }
    }
    printf("%lld ",count);
}

编辑：我想显示小于每个数组元素的元素数。这是针对上面的例子，我希望答案是：2 3 4 0 1 数组可以包含重复值。

Answer 1

以下代码段将帮助您进行查询。
它是使用 binary search 实现的，因此可以做到 log（n）时间复杂度，其中n是数组中元素的数量。

请注意，您需要先对数组排序。
，因此总时间复杂度为 n * log（n ）。

x = [{'username1': {  'attributes': { 'AccountType': ['01'], 
                            'UnitCode': ['001'], 
                            'UnitDesc': ['Marketing'], 
                            'title': ['Assistant'], }, 
            'extra': 'CN=000000'    }},
 {'username2': {  'attributes': { 'AccountType': ['01'], 
                            'UnitCode': ['002'], 
                            'UnitDesc': ['Resources'], 
                            'title': ['Manager'], }, 
            'extra': 'CN=000000'    }},
{'username3': {  'attributes': { 'AccountType': ['01'], 
                            'UnitCode': ['003'], 
                            'UnitDesc': ['Marketing_3'], 
                            'title': ['Assistant_3'], }, 
            'extra': 'CN=000000'    }},
 {'username4': {  'attributes': { 'AccountType': ['01'], 
                            'UnitCode': ['004'], 
                            'UnitDesc': ['Resources_4'], 
                            'title': ['Manager_4'], }, 
            'extra': 'CN=000000'    }}]


df = pd.DataFrame(x[0]['username1']['attributes'])
for i in range(1, len(x)):
    df = pd.concat([df, pd.DataFrame(x[i][list(x[i].keys())[0]]['attributes'])])
df.index = [list(x[i].keys())[0] for i in range(len(x))]
df.drop(['UnitDesc', 'title'], axis=1, inplace=True)



         AccountType UnitCode
username1          01      001
username2          01      002
username3          01      003
username4          01      004

Answer 2

如果您打算执行单个类似的查询，则无法改进已提出的线性方法。但是，如果您计划执行许多类似的查询，则可以对数组进行排序，然后对每个查询执行二进制搜索。这会导致每个查询的O(n*log(n))预计算复杂性和O(log(n))复杂度。请注意，如果您计划执行超过O(log(n))的查询，则此方法只会有所改进。

Answer 3

正如其他人所说，您可以通过对数组进行排序，然后在每个元素x中找到低于/高于x的第一个数字的索引，在O（nlogn）中解决它。

我想证明问题的下限：
在代数树模型下不能比Omega(nlogn) 更好（基本上没有散列）。

证明：我们将通过缩减Element Distinctness Problem来证明这一点。
假设我们有一个算法A可以在O(f(n))中解决这个问题
给定数组arr，在数组上调用A。结果是一个新数组res，其中res[i]是低于arr[i]的元素数。
请注意，对于任何两个索引i,j：res[i] == res[j] iff arr[i] == arr[j]。
如果arr中存在重复，则res中存在重复项。
但是，res中的所有元素都在[0,n-1]范围内。这意味着我们有一个元素清晰度问题，其中所有元素都由n限定。
可以使用桶排序的修改在O(n)中解决此变体。

所以，我们基本上已经在O(n + f(n))中显示了一个解决问题（Element Distinctness）的算法，但由于此模型下的元素清晰度是Omega(nlogn)问题，这意味着f(n)本身必须在Omega(nlogn)

<强> QED

Answer 4

一个简单的方法是：

首先对数组进行排序，可能使用qsort()
在已排序的数组上执行binary search。
根据数组的大小，从计算所需元素的剩余元素。

Answer 5

最简单的技巧是先对数组进行排序，然后计算数组中元素的数量。因此，例如，如果您有10个元素，那么您的第一个元素小于9，同样第二个元素小于8，依此类推。

唯一的例外是你有两个相同的项目，你必须只比较两个项目，第一个和下一个。我认为这是最可行的解决方案。

Answer 6

对数组进行排序。现在，对于每个查询，您可以将O（log n）时间减少到O（1）时间。创建一个HashMap。循环遍历排序数组的每个元素，并使用元素作为键并将排序位置作为其值填充HashMap。 HashMap提供O（1）查找，因此它比每次查询的二进制搜索更有时间效率。

Answer 7

最好的方法是使用Fenwick树/二叉索引树....专门针对此类问题而构建的数据结构，请看一下它们，Google还是看不到无法解释的视频bcoz通过输入...

如何查找大于/小于数组中元素的元素数？

7 个答案: