java編程和查找數組模式

Question

我有一個任務，我需要找到一個數組模式。這意味着我正在尋找最頻繁的整數。我已經有點完成了，但任務還說，如果有兩種模式是相同的，我應該返回最小的整數例如{1,1,1,2,2,2}應該給1（就像在我的文件中我使用該陣列，它給出了2）

public class theMode 
{ 
public theMode() 
{ 
    int[] testingArray = new int[] {1,1,1,2,2,2,4}; 
    int mode=findMode(testingArray); 
    System.out.println(mode); 
} 

public int findMode(int[] testingArray) 
{ 
    int modeWeAreLookingFor = 0; 
    int frequencyOfMode = 0; 

    for (int i = 0; i < testingArray.length; i++) 
    { 
     int currentIndexOfArray = testingArray[i]; 
     int frequencyOfEachInArray = howMany(testingArray,currentIndexOfArray); 

     if (frequencyOfEachInArray > frequencyOfMode) 
     { 
      modeWeAreLookingFor = currentIndexOfArray; 
      frequencyOfMode = modeWeAreLookingFor; 

     } 
    } 
    return modeWeAreLookingFor; 
    } 

public int howMany(int[] testingArray, int c) 
{ 
    int howManyOfThisInt=0; 
    for(int i=0; i < testingArray.length;i++) 
    { 
     if(testingArray[i]==c){ 
      howManyOfThisInt++; 
     } 
    } 
    return howManyOfThisInt; 
} 


public static void main(String[] args) 
{ 
    new theMode(); 
} 
} 

當你看到我的算法返回最後找到的模式或我應該如何解釋它。

Answer 1

這可能會稍作修改。

http://www.toves.org/books/java/ch19-array/index.html#fig2

if ((count > maxCount) || (count == maxCount && nums[i] < maxValue)) { 
    maxValue = nums[i]; 
    maxCount = count; 
} 

Answer 2

提示：當您找到頻率更高的整數時，您正在更新ModeWeAreLookingFor。如果您發現與ModeWeAreLookingFor頻率相同的整數，該怎麼辦？

額外練習：在主循環執行的第一次迭代中，計算'1'的頻率。在第二次迭代（以及第三次和第四次）中，您重新計算此值。如果存儲第一次計算的結果，則可以節省一些時間。可以用Map完成。

Java代碼約定規定方法名稱和變量名稱應該以小寫字符開頭。如果遵循此慣例，您將擁有更好的語法着色和更易於閱讀的代碼。

Answer 3

我會以不同的方式處理它。使用地圖可以將每個唯一編號用作關鍵字，然後將計數用作值。遍歷數組並查找每個找到的數字，檢查地圖以查看是否存在具有該值的鍵。如果發現其中一個值增加1，否則創建一個值爲1的新條目。

然後，您可以檢查每個映射條目的值以查看哪個條目的計數最高。如果當前鍵的計數比前一個鍵的計數更高，那麼它是「當前」答案。但是你有可能得到類似計數的密鑰，所以你需要存儲每個'winnning'的答案。

解決此問題的一種方法是檢查每個地圖的每個條目並刪除每個條目的數量小於當前的最高數量。你將留下的是所有「最高計數」的地圖。如果你的地圖只有一個條目，那麼關鍵是答案，否則你需要比較一組鍵來確定最低。

Answer 4

因爲看起來沒有其他辦法，我做了一個hashmap畢竟。在比較頻率時，我再一次陷入邏輯，如果頻率相等，同時選擇最低的整數。

 public void theMode() 
    { 
     for (Integer number: intAndFrequencyMap.keySet()) 
     { 
      int key = number; 
      int value = intAndFrequencyMap.get(number); 
      System.out.println("the integer: " +key + " exists " + value + " time(s)."); 
      int lowestIntegerOfArray = 0; 
      int highestFrequencyOfArray = 0; 
      int theInteger = 0; 
      int theModeWanted = 0; 

      if (value > highestFrequencyOfArray) 
      { 
       highestFrequencyOfArray = value; 
       theInteger = number; 
      } 
      else if (value == highestFrequencyOfArray) 
      { 
       if (number < theInteger) 
       { 
        number = theInteger; 
       } 
       else if (number > theInteger) 
       { 

       } 
       else if (number == theInteger) 
       { 
        number = theInteger; 
       } 
      } 
     } 
    } 

Answer 5

很高興您設法解決它。正如您現在所看到的，解決問題的方法不止一種。這是我的意思是使用地圖

package util; 

import java.util.HashMap; 
import java.util.Map; 

public class MathUtil { 

    public static void main(String[] args) { 
     MathUtil app = new MathUtil(); 
     int[] numbers = {1, 1, 1, 2, 2, 2, 3, 4}; 
     System.out.println(app.getMode(numbers)); 
    } 

    public int getMode(int[] numbers) { 
     int mode = 0; 
     Map<Integer, Integer> numberMap = getFrequencyMap(numbers); 

     int highestCount = 0; 

     for (int number : numberMap.keySet()) { 
      int currentCount = numberMap.get(number); 

      if (currentCount > highestCount) { 
       highestCount = currentCount; 
       mode = number; 
      } else if (currentCount == highestCount && number < mode) { 
       mode = number; 
      } 
     } 

     return mode; 
    } 

    private Map<Integer,Integer> getFrequencyMap(int[] numbers){ 
     Map<Integer, Integer> numberMap = new HashMap<Integer, Integer>(); 

     for (int number : numbers) { 
      if (numberMap.containsKey(number)) { 
       int count = numberMap.get(number); 
       count++; 
       numberMap.put(number, count); 
      } else { 
       numberMap.put(number, 1); 
      } 
     } 

     return numberMap; 
    } 
} 

Answer 6

完成：

import java.util.Arrays; 

public class TheMode                         
{ 
    //Probably not the most effective solution, but works without hashmap 
    //or any sorting algorithms 

public TheMode() 
{ 
    int[] testingArray = new int[] {2,3,5,4,2,3,3,3}; 
    int mode = findMode(testingArray); 
    System.out.println(Arrays.toString(testingArray)); 
    System.out.println("The lowest mode is: " + mode); 

    int[] test2 = new int[] {3,3,2,2,1}; 
    int mode2=findMode(test2); 
    System.out.println(Arrays.toString(test2)); 
    System.out.println("The lowest mode is: " +mode2); 

    int[] test3 = new int[] {4,4,5,5,1}; 
    int mode3 = findMode(test3); 
    System.out.println(Arrays.toString(test3)); 
    System.out.println(The lowest mode is: " +mode3); 
} 

public int findMode(int[] testingArray) 
{ 
    int modeWeAreLookingFor = 0; 
    int frequencyOfMode = 0; 

    for (int i = 0; i < testingArray.length; i++) 
    { 
     int currentIndexOfArray = testingArray[i]; 
     int countIntegerInArray = howMany(testingArray, currentIndexOfArray); 

     if (countIntegerInArray == frequencyOfMode) 
     { 
      if (modeWeAreLookingFor > currentIndexOfArray) 
      { 
       modeWeAreLookingFor = currentIndexOfArray; 
      } 
     } 

     else if (countIntegerInArray > frequencyOfMode) 
     { 
      modeWeAreLookingFor = currentIndexOfArray; 
      frequencyOfMode = countIntegerInArray;    
     } 

    } 
    return modeWeAreLookingFor; 
    } 

public int howMany(int[] testingArray, int c) 
{ 

    int howManyOfThisInt=0; 
    for(int i=0; i < testingArray.length;i++) 
    { 
     if(testingArray[i]==c){ 
      howManyOfThisInt++; 

     } 
    } 
    return howManyOfThisInt; 
} 


public static void main(String[] args) 
{ 
    new TheMode(); 
} 
}