• Fantius, how bout this?

将该清单与雷达Sort(BucketSort)算法(技术上为O(N)时间;数字必须分类。 从第一个要素开始,铭记其价值,开始计算1。 在你达到不同价值之前,通过名单上删除该数字。 如果这一数值的计算高于目前的高数值,则记住这一价值并算作模式。 如果你与高点挂钩,就会记住(或全部)数字。

...... 是的,是的,RadixSort并不是一种内部的,因此,涉及你可以称之为“清醒”的东西(按现任数字编出的收集资料)。 然而,该表被用于分类,而不是计算方式。

我要说的是,在一份未经许可的清单中,如果不涉及一个敏感的SOMEWHERE,就不可能按部就班地计算这一模式。 在分类清单中,该算法的后半部分仅跟踪现行最高算法。

象家庭工作这样的明显健康。 但尝试这样做:一度通过名单,数量最多。 形成一系列的愤怒,其中有许多因素,最初都是零。 之后,再次逐个逐个逐个逐个逐个逐个逐个逐个逐个增加。 最后,扫描你的阵列,并退还价值最高的指数。 这将在大约线性时间进行,而任何包含某种算法的算法很可能需要NlogN的时间或更糟的时间。 然而,这一解决办法是记忆犹新;它基本上只给你一个席位。

认为许多(但并非全部)语文使用零基的阵列,因此,从“自然”号改为指数,分数一,然后从指数改为自然数字。

如果你不希望使用散装,则使用经过改装的双轨搜索仪(每秒钟有一个反面)。 阵列中的每一部分都插入三边。 如果在三角地已经存在,则会增加反射。 最终,最高点为 no。

当然,你也可以使用一个地图,绘制反变量的地图,并将以同样的方式工作。 我不理解你关于它不是一种挑衅的说法。 你们通过阵列敲响,然后,你通过散列图成员敲响,以找到最高级别的反响。

仅使用计数,并研究储存每个实体发生次数的阵列。

我在沙尔准备了两个具有不同空间和时间复杂性的节目:

第一个使用“风险阵列”是指O(k)在时间复杂方面,S(k+1)在所需空间方面,K是投入最多的。

input =[1,2,3,8,4,6,1,3,7,9,6,1,9]

def find_max(tab):
    max=tab[0]
    for i in range(0,len(tab)):
        if tab[i] > max:
            max=tab[i]
    return max

C = [0]*(find_max(input)+1)
print len(C)
def count_occurences(tab):
    max_occurence=C[0]
    max_occurence_index=0
    for i in range(0,len(tab)):
        C[tab[i]]=C[tab[i]]+1
        if C[tab[i]]>max_occurence:
            max_occurence = C[tab[i]]
            max_occurence_index=tab[i]
    return max_occurence_index

print count_occurences(input)

NOTE: Imagine such pitiful example of submissions as an range [1, 10^8,1,1,1,1], there will be range of length k+1=100000001 need.

第二种解决办法假定,我们在寻找模式之前就把我们的意见分类。 我使用的是rad形,它有时间的复杂性O(kn),其中K是最长数量,N是投入阵列的大小。 那么,我们必须整整整整块地块地块地块地块地块,确定最长的排位,以适应模式。

input =[1,2,3,8,4,6,1,3,7,9,6,1,9]

def radix_sort(A):
    len_A = len(A)
    mod = 5 #init num of buckets
    div = 1
    while True:
        the_buckets =  [[], [], [], [], [], [], [], [], [], []]
        for value in A:
            ldigit = value % mod
            ldigit = ldigit / div
            the_buckets[ldigit].append(value)
        mod = mod * 10
        div = div * 10
        if len(the_buckets[0]) == len_A:
            return the_buckets[0]
        A = []
        rd_list_append = A.append
        for b in the_buckets:
            for i in b:
                rd_list_append(i)     

def find_mode_in_sorted(A):
    mode=A[0]
    number_of_occurences =1
    number_of_occurences_canidate=0
    for i in range(1,len(A)):
        if A[i] == mode:
            number_of_occurences =number_of_occurences +1
        else:
            number_of_occurences_canidate=number_of_occurences_canidate+1
        if A[i] != A[i-1]:
            number_of_occurences_canidate=0
        if number_of_occurences_canidate > number_of_occurences :
            mode=A[i]
            number_of_occurences =number_of_occurences_canidate+1
    return mode#,number_of_occurences 

s_input=radix_sort(input)
print find_mode_in_sorted(s_input)

利用 Java文:

const mode = (arr) => {
    let numMapping = {};
    let mode
    let greatestFreq = 0;
    for(var i = 0; i < arr.length; i++){
        if(numMapping[arr[i]] === undefined){
            numMapping[arr[i]] = 0;
        }
        numMapping[arr[i]] += 1;
        if (numMapping[arr[i]] > greatestFreq){
          greatestFreq = numMapping[arr[i]]
          mode = arr[i]
        }
    }
    return parseInt(mode)
}