【发布时间】：2011-12-17 15:03:24
【问题描述】：
int[] a = new int[10]{1,2,3,4,5,6,7,7,7,7};
如何编写方法并返回 7？
我想在不借助列表、地图或其他助手的情况下保持它的原生性。 只有数组[]。
【问题讨论】：
【发布时间】：2011-12-17 15:03:24
【问题描述】：
试试这个答案。一、数据：
int[] a = {1,2,3,4,5,6,7,7,7,7};
在这里，我们构建了一个地图，计算每个数字出现的次数：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i : a) {
Integer count = map.get(i);
map.put(i, count != null ? count+1 : 1);
}
现在，我们找到频率最高的数字并将其返回：
Integer popular = Collections.max(map.entrySet(),
new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
return o1.getValue().compareTo(o2.getValue());
}
}).getKey();
如您所见，最受欢迎的数字是 7：
System.out.println(popular);
> 7
编辑
这是我的答案没有使用地图、列表等并且只使用数组；虽然我正在对数组进行就地排序。它的复杂度为 O(n log n)，比 O(n^2) 公认的解决方案要好。
public int findPopular(int[] a) {
if (a == null || a.length == 0)
return 0;
Arrays.sort(a);
int previous = a[0];
int popular = a[0];
int count = 1;
int maxCount = 1;
for (int i = 1; i < a.length; i++) {
if (a[i] == previous)
count++;
else {
if (count > maxCount) {
popular = a[i-1];
maxCount = count;
}
previous = a[i];
count = 1;
}
}
return count > maxCount ? a[a.length-1] : popular;
}
【讨论】：
-
在空引用或长度为 0 的情况下返回 0 不是一个好主意，因为在这种情况下 0 很可能是有效元素。
-
在统计出现次数的map中，如果count为null，表示找到的元素是第一次出现，那为什么不放1而不是0呢？
-
@MassimilianoGiunchi 你是对的！感谢您发现该错误，现已修复
public int getPopularElement(int[] a)
{
int count = 1, tempCount;
int popular = a[0];
int temp = 0;
for (int i = 0; i < (a.length - 1); i++)
{
temp = a[i];
tempCount = 0;
for (int j = 1; j < a.length; j++)
{
if (temp == a[j])
tempCount++;
}
if (tempCount > count)
{
popular = temp;
count = tempCount;
}
}
return popular;
}
【讨论】：
-
感谢您的解决方案。我感到惊讶只是因为您的答案被接受为正确答案，并且通常在计算机科学中 o(n2) 不是最佳答案。但是您的解决方案绝对更容易理解简单直观。伙计，你在 Stackoverflow 上得分很高。赞！！！
-
@gabhi：我在看了 OP 的问题后马上就做到了。从来没有在复杂性方面考虑过太多，但如果你能做到，我很乐意马上投票:-)
-
我猜把每个整数的频率放在哈希表中可以把它降低到线性时间。
-
@nIcEcOw 甚至有人必须使用两个循环，我在这里看到了即兴创作的范围。查看我的答案
-
如果我们使用作为输入的任意字符串而不是整数字符串，您的代码会有很多变化吗？ （任意字符串，例如：'今天是 8 月 6 日 aaa'，所以最流行的字母是 a）
- 取一个映射到映射元素 -> 计数
- 遍历数组并处理地图
- 遍历地图，找出热门
【讨论】：
-
好答案。您可能想提一下，如果原始数字被限制在一个相对较小的最大值（例如 100 或 1000），您可以使用数组而不是地图。
-
@dasb
Map很好，相对于数组的任何优点，我认为它没有任何缺点 -
我怎样才能做到原生？仅借助临时数组
-
@dasb 刚接触 Java 的程序员经常发现数组比映射更容易理解。考虑到措辞（实际上是问题的内容），毫无疑问，OP 是编程的新手（而不仅仅是 Java 编程）。这很可能是他的功课。
-
您现在有一个数据数组，您需要的是计数数组，例如，如果您的数据数组中的第 0 个元素是
1，第一个元素是2，那么在 oyur 计数数组中您应该持有 @987654324 @ 那是1的计数等等..
假设您的数组已排序（就像您发布的那样），您可以简单地遍历数组并计算最长的元素段，这类似于 @narek.gevorgyan 的帖子，但没有非常大的数组，它使用相同内存量与数组大小无关：
private static int getMostPopularElement(int[] a){
int counter = 0, curr, maxvalue, maxcounter = -1;
maxvalue = curr = a[0];
for (int e : a){
if (curr == e){
counter++;
} else {
if (counter > maxcounter){
maxcounter = counter;
maxvalue = curr;
}
counter = 0;
curr = e;
}
}
if (counter > maxcounter){
maxvalue = curr;
}
return maxvalue;
}
public static void main(String[] args) {
System.out.println(getMostPopularElement(new int[]{1,2,3,4,5,6,7,7,7,7}));
}
如果数组没有排序，用Arrays.sort(a);排序
【讨论】：
使用 Java 8 流
int data[] = { 1, 5, 7, 4, 6, 2, 0, 1, 3, 2, 2 };
Map<Integer, Long> count = Arrays.stream(data)
.boxed()
.collect(Collectors.groupingBy(Function.identity(), counting()));
int max = count.entrySet().stream()
.max((first, second) -> {
return (int) (first.getValue() - second.getValue());
})
.get().getKey();
System.out.println(max);
说明
我们将int[] data 数组转换为盒装整数流。然后我们通过groupingBy对元素进行收集，并在groupBy之后使用二级计数收集器进行计数。
最后，我们使用流和 lambda 比较器再次根据 count 对元素 -> count 的映射进行排序。
【讨论】：
这个没有地图：
public class Main {
public static void main(String[] args) {
int[] a = new int[]{ 1, 2, 3, 4, 5, 6, 7, 7, 7, 7 };
System.out.println(getMostPopularElement(a));
}
private static int getMostPopularElement(int[] a) {
int maxElementIndex = getArrayMaximumElementIndex(a);
int[] b = new int[a[maxElementIndex] + 1]
for (int i = 0; i < a.length; i++) {
++b[a[i]];
}
return getArrayMaximumElementIndex(b);
}
private static int getArrayMaximumElementIndex(int[] a) {
int maxElementIndex = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] >= a[maxElementIndex]) {
maxElementIndex = i;
}
}
return maxElementIndex;
}
}
如果您的数组可以包含< 0 的元素，您只需更改一些代码。
当您的数组项不是大数字时，此算法很有用。
【讨论】：
如果您不想使用地图，请按照以下步骤操作：
- 对数组进行排序（使用
Arrays.sort()） - 使用一个变量来保存最流行的元素（mostPopular），一个变量来保存它在数组中的出现次数（mostPopularCount），以及一个变量来保存当前数字在迭代中的出现次数（currentCount）
- 遍历数组。如果当前元素与 mostPopular 相同，则增加 currentCount。如果不是，则将 currentCount 重置为 1。如果 currentCount > mostPopularCount，则将 mostPopularCount 设置为 currentCount，将 mostPopular 设置为当前元素。
【讨论】：
-
是的，显然比我的回答要好。
-
但也许他的数组大小很大，数字很小。在这种情况下，我的更好。
您似乎正在寻找 Mode 值（统计模式），请查看 Apache's Docs 了解统计功能。
【讨论】：
package frequent;
import java.util.HashMap;
import java.util.Map;
public class Frequent_number {
//Find the most frequent integer in an array
public static void main(String[] args) {
int arr[]= {1,2,3,4,3,2,2,3,3};
System.out.println(getFrequent(arr));
System.out.println(getFrequentBySorting(arr));
}
//Using Map , TC: O(n) SC: O(n)
static public int getFrequent(int arr[]){
int ans=0;
Map<Integer,Integer> m = new HashMap<>();
for(int i:arr){
if(m.containsKey(i)){
m.put(i, m.get(i)+1);
}else{
m.put(i, 1);
}
}
int maxVal=0;
for(Integer in: m.keySet()){
if(m.get(in)>maxVal){
ans=in;
maxVal = m.get(in);
}
}
return ans;
}
//Sort the array and then find it TC: O(nlogn) SC: O(1)
public static int getFrequentBySorting(int arr[]){
int current=arr[0];
int ansCount=0;
int tempCount=0;
int ans=current;
for(int i:arr){
if(i==current){
tempCount++;
}
if(tempCount>ansCount){
ansCount=tempCount;
ans=i;
}
current=i;
}
return ans;
}
}
【讨论】：
数组元素的值应该小于这个数组的长度：
public void findCounts(int[] arr, int n) {
int i = 0;
while (i < n) {
if (arr[i] <= 0) {
i++;
continue;
}
int elementIndex = arr[i] - 1;
if (arr[elementIndex] > 0) {
arr[i] = arr[elementIndex];
arr[elementIndex] = -1;
}
else {
arr[elementIndex]--;
arr[i] = 0;
i++;
}
}
Console.WriteLine("Below are counts of all elements");
for (int j = 0; j < n; j++) {
Console.WriteLine(j + 1 + "->" + Math.Abs(arr[j]));
}
}
时间复杂度为O(N)，空间复杂度为O(1)。
【讨论】：
import java.util.Scanner;
public class Mostrepeatednumber
{
public static void main(String args[])
{
int most = 0;
int temp=0;
int count=0,tempcount;
Scanner in=new Scanner(System.in);
System.out.println("Enter any number");
int n=in.nextInt();
int arr[]=new int[n];
System.out.print("Enter array value:");
for(int i=0;i<=n-1;i++)
{
int n1=in.nextInt();
arr[i]=n1;
}
//!!!!!!!! user input concept closed
//logic can be started
for(int j=0;j<=n-1;j++)
{
temp=arr[j];
tempcount=0;
for(int k=1;k<=n-1;k++)
{
if(temp==arr[k])
{
tempcount++;
}
if(count<tempcount)
{
most=arr[k];
count=tempcount;
}
}
}
System.out.println(most);
}
}
【讨论】：
-
请为您的代码添加一些解释 - 这将有助于其他人在未来看到您的答案
最好的方法是使用 map，其中键是元素，值是每个元素的计数。除此之外，还要保留一个包含最流行元素索引的大小数组。在地图构建时填充这个数组，这样我们就不必再次遍历地图。
方法2：-
如果有人想用两个循环，这里是接受答案的即兴创作，我们不必每次都从一个开始第二个循环
public class TestPopularElements {
public static int getPopularElement(int[] a) {
int count = 1, tempCount;
int popular = a[0];
int temp = 0;
for (int i = 0; i < (a.length - 1); i++) {
temp = a[i];
tempCount = 0;
for (int j = i+1; j < a.length; j++) {
if (temp == a[j])
tempCount++;
}
if (tempCount > count) {
popular = temp;
count = tempCount;
}
}
return popular;
}
public static void main(String[] args) {
int a[] = new int[] {1,2,3,4,5,6,2,7,7,7};
System.out.println("count is " +getPopularElement(a));
}
}
【讨论】：
假设您的 int 数组已排序，我会这样做...
int count = 0, occur = 0, high = 0, a;
for (a = 1; a < n.length; a++) {
if (n[a - 1] == n[a]) {
count++;
if (count > occur) {
occur = count;
high = n[a];
}
} else {
count = 0;
}
}
System.out.println("highest occurence = " + high);
【讨论】：
public static int getMostCommonElement(int[] array) {
Arrays.sort(array);
int frequency = 1;
int biggestFrequency = 1;
int mostCommonElement = 0;
for(int i=0; i<array.length-1; i++) {
frequency = (array[i]==array[i+1]) ? frequency+1 : 1;
if(frequency>biggestFrequency) {
biggestFrequency = frequency;
mostCommonElement = array[i];
}
}
return mostCommonElement;
}
【讨论】：
-
请注意，对数组进行排序会产生副作用。
挖掘线性 O(N)
使用 map 保存数组中找到的所有不同元素并保存发生的次数，然后从 map 中获取最大值。
import java.util.HashMap;
import java.util.Map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.IntStream;
public class MosftOftenNumber {
// for O(N) + map O(1) = O(N)
public static int mostOftenNumber(int[] a)
{
final Map m = new HashMap<Integer,Integer>();
int max = 0;
int element = 0;
for (int i=0; i<a.length; i++){
//initializing value for the map the value will have the counter of each element
//first time one new number its found will be initialize with zero
if (m.get(a[i]) == null)
m.put(a[i],0);
//save each value from the array and increment the count each time its found
m.put(a[i] , (Integer) m.get(a[i]) + 1);
//check the value from each element and comparing with max
if ( (Integer) m.get(a[i]) > max){
max = (Integer) m.get(a[i]);
element = a[i];
}
}
System.out.println("Times repeated: " + max);
return element;
}
public static int mostOftenNumberWithLambdas(int[] a)
{
Integer max = IntStream.of(a).boxed().max(Integer::compareTo).get();
Integer coumtMax = Math.toIntExact(IntStream.of(a).boxed().filter(number -> number.equals(max)).count());
System.out.println("Times repeated: " + coumtMax);
return max;
}
public static void main(String args[]) {
// int[] array = {1,1,2,1,1};
// int[] array = {2,2,1,2,2};
int[] array = {1,2,3,4,5,6,7,7,7,7};
System.out.println("Most often number with loops: " + mostOftenNumber(array));
System.out.println("Most often number with lambdas: " + mostOftenNumberWithLambdas(array));
}
}
【讨论】：
-
请解释你的答案，而不是只显示代码
-
这甚至无法编译
-
现在编译我让一些代码在主取消注释，并在函数内添加更多的 cmets。
解决方案 1：哈希图：O(n)
def most_freq_elem(arr):
frequency = {}
most_frequent, most_count = -1, 0
for num in arr:
frequency[num] = frequency.get(num, 0) + 1
if frequency[num] > most_count:
most_count = frequency[num]
most_frequent = num
return most_frequent
解决方案 2：哈希图 + 最大值：O(n)
def most_freq_elem(arr):
frequency = {}
for num in arr:
frequency[num] = frequency.get(num, 0) + 1
return max(frequency, key=frequency.get)
【讨论】：
public static void main(String[] args) {
int[] myArray = {1,5,4,4,22,4,9,4,4,8};
Map<Integer,Integer> arrayCounts = new HashMap<>();
Integer popularCount = 0;
Integer popularValue = 0;
for(int i = 0; i < myArray.length; i++) {
Integer count = arrayCounts.get(myArray[i]);
if (count == null) {
count = 0;
}
arrayCounts.put(myArray[i], count == 0 ? 1 : ++count);
if (count > popularCount) {
popularCount = count;
popularValue = myArray[i];
}
}
System.out.println(popularValue + " --> " + popularCount);
}
【讨论】：
下面的代码可以放在main方法中
// TODO Auto-generated method stub
Integer[] a = { 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 1, 2, 2, 2, 2, 3, 4, 2 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(a));
Set<Integer> set = new HashSet<Integer>(list);
int highestSeq = 0;
int seq = 0;
for (int i : set) {
int tempCount = 0;
for (int l : list) {
if (i == l) {
tempCount = tempCount + 1;
}
if (tempCount > highestSeq) {
highestSeq = tempCount;
seq = i;
}
}
}
System.out.println("highest sequence is " + seq + " repeated for " + highestSeq);
【讨论】：
public class MostFrequentIntegerInAnArray {
public static void main(String[] args) {
int[] items = new int[]{2,1,43,1,6,73,5,4,65,1,3,6,1,1};
System.out.println("Most common item = "+getMostFrequentInt(items));
}
//Time Complexity = O(N)
//Space Complexity = O(N)
public static int getMostFrequentInt(int[] items){
Map<Integer, Integer> itemsMap = new HashMap<Integer, Integer>(items.length);
for(int item : items){
if(!itemsMap.containsKey(item))
itemsMap.put(item, 1);
else
itemsMap.put(item, itemsMap.get(item)+1);
}
int maxCount = Integer.MIN_VALUE;
for(Entry<Integer, Integer> entry : itemsMap.entrySet()){
if(entry.getValue() > maxCount)
maxCount = entry.getValue();
}
return maxCount;
}
}
【讨论】：
int largest = 0;
int k = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j]) {
count++;
}
}
if (count > largest) {
k = a[i];
largest = count;
}
}
所以这里n 是数组的长度，a[] 是你的数组。
首先，取第一个元素并检查它重复了多少次，并增加计数器 (count) 以查看它出现了多少次。
如果是，请检查该数字迄今为止出现的最大次数，然后更改最大变量（以存储最大重复次数），如果您也想存储该变量，您可以在另一个变量中执行此操作（这里是k）。
我知道这不是最快的，但绝对是最容易理解的方法
【讨论】：
-
虽然这段代码 sn-p 可以解决问题，但including an explanation 确实有助于提高帖子的质量。请记住，您是在为将来的读者回答问题，而这些人可能不知道您提出代码建议的原因。
-
@Clijsters 现在已经这样做了，但对这个平台来说还是新手，我无法在这里编写多行 cmets
-
评论不能多行。如果您的意思是答案文本，则为降价；这意味着新段落需要两次返回。这在小帮助框中进行了解释。
-
哦，但是我用这个 /* */ 来处理多行 cmets？
-
您可能想看看Hos do I write a good answer?。我不明白你的意思。 java中的多行cmets？是的，没错。
import java.util.HashMap;
import java.util.Map;
import java.lang.Integer;
import java.util.Iterator;
public class FindMood {
public static void main(String [] args){
int arrayToCheckFrom [] = {1,2,4,4,5,5,5,3,3,3,3,3,3,3,3};
Map map = new HashMap<Integer, Integer>();
for(int i = 0 ; i < arrayToCheckFrom.length; i++){
int sum = 0;
for(int k = 0 ; k < arrayToCheckFrom.length ; k++){
if(arrayToCheckFrom[i]==arrayToCheckFrom[k])
sum += 1;
}
map.put(arrayToCheckFrom[i], sum);
}
System.out.println(getMaxValue(map));
}
public static Integer getMaxValue( Map<Integer,Integer> map){
Map.Entry<Integer,Integer> maxEntry = null;
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<Integer,Integer> pair = (Map.Entry<Integer,Integer>) iterator.next();
if(maxEntry == null || pair.getValue().compareTo(maxEntry.getValue())>0){
maxEntry = pair;
}
}
return maxEntry.getKey();
}
}
【讨论】：
比较两个数组，希望对你有用。
public static void main(String []args){
int primerArray [] = {1,2,1,3,5};
int arrayTow [] = {1,6,7,8};
int numberMostRepetly = validateArrays(primerArray,arrayTow);
System.out.println(numberMostRepetly);
}
public static int validateArrays(int primerArray[], int arrayTow[]){
int numVeces = 0;
for(int i = 0; i< primerArray.length; i++){
for(int c = i+1; c < primerArray.length; c++){
if(primerArray[i] == primerArray[c]){
numVeces = primerArray[c];
// System.out.println("Numero que mas se repite");
//System.out.println(numVeces);
}
}
for(int a = 0; a < arrayTow.length; a++){
if(numVeces == arrayTow[a]){
// System.out.println(numVeces);
return numVeces;
}
}
}
return 0;
}
【讨论】：
public class MostFrequentNumber {
public MostFrequentNumber() {
}
int frequentNumber(List<Integer> list){
int popular = 0;
int holder = 0;
for(Integer number: list) {
int freq = Collections.frequency(list,number);
if(holder < freq){
holder = freq;
popular = number;
}
}
return popular;
}
public static void main(String[] args){
int[] numbers = {4,6,2,5,4,7,6,4,7,7,7};
List<Integer> list = new ArrayList<Integer>();
for(Integer num : numbers){
list.add(num);
}
MostFrequentNumber mostFrequentNumber = new MostFrequentNumber();
System.out.println(mostFrequentNumber.frequentNumber(list));
}
}
【讨论】：
您可以计算不同数字的出现次数，然后查找最高的数字。这是一个使用 Map 的示例，但可以相对容易地适应原生数组。
第二大元素： 让我们举个例子：[1,5,4,2,3] 在这种情况下， 第二大元素将是 4。
按降序对数组进行排序，排序完成后输出将是 A = [5,4,3,2,1]
使用索引 1 从已排序的数组中获取第二大元素。A[1] -> 这将给出第二大元素 4。
私有静态 int getMostOccuringElement(int[] A) { 映射发生Map = new HashMap();
//count occurences
for (int i = 0; i < A.length; i++) {
if (occuringMap.get(A[i]) != null) {
int val = occuringMap.get(A[i]) + 1;
occuringMap.put(A[i], val);
} else {
occuringMap.put(A[i], 1);
}
}
//find maximum occurence
int max = Integer.MIN_VALUE;
int element = -1;
for (Map.Entry<Integer, Integer> entry : occuringMap.entrySet()) {
if (entry.getValue() > max) {
max = entry.getValue();
element = entry.getKey();
}
}
return element;
}
【讨论】：
-
请在您的代码中添加一些解释，以获得完整的答案！
-
第二大元素：让我们举个例子：[1,5,4,2,3] 在这种情况下，第二大元素将是 4。 1. 按降序对数组进行排序，一旦排序完成输出将是 A = [5,4,3,2,1] 2. 使用索引 1 从排序数组中获取第二大元素。 A[1] -> 这将给出第二大元素 4
-
@ArnavBorborah 希望解释清楚
-
我的意思是您可能应该将您在该评论中写的内容添加到您的答案中。 （使用编辑按钮）。
我希望这会有所帮助。
public class Ideone {
public static void main(String[] args) throws java.lang.Exception {
int[] a = {1,2,3,4,5,6,7,7,7};
int len = a.length;
System.out.println(len);
for (int i = 0; i <= len - 1; i++) {
while (a[i] == a[i + 1]) {
System.out.println(a[i]);
break;
}
}
}
}
【讨论】：
这是错误的语法。创建匿名数组时，不得提供其大小。
当你编写以下代码时：
new int[] {1,23,4,4,5,5,5};
您在这里创建一个匿名 int 数组，其大小将由您在花括号中提供的值的数量决定。
您可以像以前一样为其分配一个引用，但这将是相同的正确语法：-
int[] a = new int[]{1,2,3,4,5,6,7,7,7,7};
现在，只需使用正确索引位置的 Sysout：
System.out.println(a[7]);
【讨论】：
-
我严重怀疑这是 OP 的问题。
-
他想要最频繁的数字。不是这个。