Java 错在哪里？寻找多数

我想找到数组中的多数（大多数时间出现的数字）。 我有一个排序数组并使用以下循环：

for(int k = 1;k < length;k++)
{
    if(arr[k-1] == arr[k])
    {
        count++;
        if(count > max)
        {
            max = count;
            maxnum = arr[k-1];
        }
    } else {
        count = 0;
    }
}

for（int k=1；k最大值）
{
最大值=计数；
maxnum=arr[k-1]；
}
}否则{
计数=0；
}
}

或

---

for（int h=0；h仅当数组已排序时，第一个算法才有意义

您的第二个算法只是在错误的位置将count设置为零。您希望在输入内部
for
循环之前将count设置为零

 for(int h=0;h<length;h++)
 {
  count = 0;
  for(int l=0;l<length;l++)
  {
   if(arr[h] == arr[l])
   {
    count++;
    if(count > max)
    {
     max = count;
     maxnum = arr[h];
    }
   }
  }
 }

我很容易看到的错误是，如果所有元素都是不同的，那么末尾的最大值是0。
但是它必须是1。
因此，当您在“else”情况下更新count时，将其更新为1而不是0，因为已发现新元素，并且其计数为1。
首先，您应该使用
第一个算法，因为数组已排序。第二个算法不必要地在数组中运行两次

现在您的
第一个算法
几乎是正确的，但它有两个问题：-


第一个问题是，在else部分中，您正在设置计数=0，
相反，它应该设置为
1
，因为每个元素至少都有一个值
一次
其次，您不需要在
if
中每次都设置
max
递增计数
，直到满足
条件
，并尽快
当
条件失败时
，用
电流检查
电流计数
最大值
，并相应地重置当前最大值

这样，您的
max
将不会在每次迭代中都进行检查，而仅在发现不匹配时进行检查

因此，您可以尝试以下代码：-

    // initialize `count = 1`, and `maxnum = Integer.MIN_VALUE`.
    int count = 1;
    int max = 0;
    int maxnum = Integer.MIN_VALUE;

    for(int k = 1;k < length;k++)
     {
         if(arr[k-1] == arr[k]) {
              count++;   // Keep on increasing count till elements are equal

         } else {
             // if Condition fails, check for the current count v/s current max

             if (max < count) {   // Move this from `if` to `else`
                 max = count;
                 maxnum = arr[k - 1];
             }
             count = 1;  // Reset count to 1. As every value comes at least once.
         }
     }

//初始化'count=1'和'maxnum=Integer.MIN\u值'。
整数计数=1；
int max=0；
int maxnum=Integer.MIN\u值；
for（int k=1；k

注意：-

这种方法的问题是，如果两个数字表示-
1
和
3
的次数相等-即最大，则
max
计数将被计算为
3
（假设
3
位于
1
之后，
maxnum
将包含
3
并忽略
1
。但应考虑这两种情况

因此，基本上，您不能使用
for循环
和维护
计数来解决此问题

更好的方法是创建一个
映射
，并将每个值的计数存储在其中。然后在
上对
映射
进行排序
在
值
上你的第一个算法在我看来是正确的。第二个算法（这是链接代码使用的）每次通过循环都需要一些初始化。此外，内部循环不需要每次在
1
处启动；它可以在
h+1
处启动：

for(int h=0; h<length; h++)
{
    count = 1; // for the element at arr[h]
    for(int l=h + 1; l<length; l++)
    {
        if(arr[h] == arr[l])
        {
            count++;
        }
    }
    if(count > max)
    {
        max = count;
        maxnum = arr[h];
    }
}

用于（int h=0；在第二个算法中，循环计数器的第二个
可能从
h
开始，而不是
1
。第一个算法比第二个算法效率高很多，而且它们并不等效。第一个算法看起来正常，第二个则不正常。第一个代码似乎正确。第二个方法似乎是为未排序的数组设计的。它需要为
h
的每个值重置
count
。第一个算法对于排序数组来说非常有意义（相等的值将是连续的）。谢谢！第一个算法是正确的，但第二个算法没有通过测试（我在检查）。谢谢！我使用了map，但它需要更多的内存。否则它会更好。@Will\u code\u 4\u food..在这种情况下，不要存储所有的int，在其中计算映射。只需使用当前的Max count存储int值，并在Max发生变化时更新它，如果发现两个值具有相同的Max值，则将它们都存储。您需要使用这种方法，以请确保在所有情况下都得到正确的结果。@TedHopp..您还应该引用在以下情况下这不会给出正确的结果：-[1,1,2,2,3]。它将只给出
2
作为最大计数。但它应该同时给出
1
和
2
@RohitJain-实际上它将给出2作为
max
计数，将给出1作为
maxnum
。但是你是对的——我将澄清，如果出现平局，它将返回第一个最大值。
    // initialize `count = 1`, and `maxnum = Integer.MIN_VALUE`.
    int count = 1;
    int max = 0;
    int maxnum = Integer.MIN_VALUE;

    for(int k = 1;k < length;k++)
     {
         if(arr[k-1] == arr[k]) {
              count++;   // Keep on increasing count till elements are equal

         } else {
             // if Condition fails, check for the current count v/s current max

             if (max < count) {   // Move this from `if` to `else`
                 max = count;
                 maxnum = arr[k - 1];
             }
             count = 1;  // Reset count to 1. As every value comes at least once.
         }
     }

for(int h=0; h<length; h++)
{
    count = 1; // for the element at arr[h]
    for(int l=h + 1; l<length; l++)
    {
        if(arr[h] == arr[l])
        {
            count++;
        }
    }
    if(count > max)
    {
        max = count;
        maxnum = arr[h];
    }
}