java在排序数组上迭代并存储不同整数的计数

Question

有人能回答我的具体问题吗？我不能使用课堂上没有涉及的材料，必须这样做

我试图迭代一个排序数组，如果前面的数字==当前数字，它将以新数组的形式存储计数；当上一个号码出现时！=当前数字，然后在新数组上移动到n+1，并再次开始计数

我现在正在调试它，但很难找出它不工作的地方。非常感谢您的帮助

    // Get the count of instances.
    int[] countOfNumbers = new int[50];         // Array to store count
    int sizeOfArray = 0;                        // Last position of array filled
    int instanceCounter = 1;                    // Counts number of instances
    int previousNumber = 0;                     // Number stored at [k-1]

    for (int k=1; k < finalArrayOfNumbers.length; k++) {
        previousNumber = finalArrayOfNumbers[k-0];

        if (previousNumber == finalArrayOfNumbers[k]) {

            instanceCounter++;
            countOfNumbers[sizeOfArray] = instanceCounter;

        }

        instanceCounter = 1; 
        sizeOfArray++;
        countOfNumbers[sizeOfArray] = instanceCounter;

不用担心映射或其他问题，我只需要知道如果我有一个数组：

[20,20,40,40,50]

我能回来

[2,2,1]

Answer 1

I'm debugging it now but having trouble working out what it isn't work. Any help is much appreciated.

给你一个线索：

      previousNumber = finalArrayOfNumbers[k-0];
      if (previousNumber == finalArrayOfNumbers[k]) {

提示：“k-0”与上面的“k”具有相同的值

线索2：如果你的意图是previousNumber包含你当前正在计数的数字，那么它需要在循环的之外进行初始化，当当前数字改变时更新

提示3：你不应该在每次循环迭代中增加sizeOfArray

基于你的问题，我想说你对所写代码的思考/理解是模糊的。这就是为什么调试它会有困难

为了有效地调试一段代码，你首先需要一个关于它应该如何工作的心智模型。然后使用调试器观察关键点发生的情况，以确认程序是否按预期运行

（如果你在没有心理模型的情况下进入调试过程，你所看到的只是语句的执行、变量的变化等等，而没有任何东西可以告诉你是否发生了正确的事情。这就像看一部老电影中电脑上的闪光灯……没有启发性。）

Answer 2

Java API中有很多简洁的工具，因此您可以避免自己做很多这类事情：

    List<Integer> list = Arrays.asList(20, 20, 40, 40, 50);
    Map<Integer, Integer> freq = new LinkedHashMap<>();
    for (int i: list) {
        freq.put(i, Collections.frequency(list, i));
    }
    System.out.println(freq.values());

那会像你想的那样打印[2, 2, 1]

或者，如果希望列表中只包含不同的值，可以使用Set的实现

但因为这是一项课堂作业，所以你受到了限制，所以你可以这样做：

    int[] a = { 20, 20, 40, 40, 50 };
    int[] freq = new int[a.length];
    // count frequencies
    for (int i = 1, j = 0, count = 1; i <= a.length; i++, count++) {
        if (i == a.length || a[i] != a[i - 1]) {
            freq[j++] = count;
            count = 0;
        }
    }
    // print
    for (int i = 0; i < freq.length && freq[i] != 0; i++) {
        System.out.println(freq[i]);
    }

输出仍然是一样的

我在你离开的两个地方发表了评论，这是你的固定代码

    for (int k = 1; k < finalArrayOfNumbers.length; k++) {
        previousNumber = finalArrayOfNumbers[k - 1]; // changed 0 to 1
        if (previousNumber == finalArrayOfNumbers[k]) {
            instanceCounter++;
            countOfNumbers[sizeOfArray] = instanceCounter;
        } else { // put this last bit in an else block
            instanceCounter = 1;
            sizeOfArray++;
            countOfNumbers[sizeOfArray] = instanceCounter;
        }
    }

Answer 3

我会选择一个hashmap，其中键是数字，值是计数。这样你就有了一个唯一的数字和计数。你的解决方案遇到了一个问题，你不知道在索引i处，这个数字属于什么计数，除非你的列表没有重复项，并且没有间隔，比如1，2，3，4，5，而不是1，1，1，1，5，5

HashMap<Integer, Integer> occurances = new HashMap>Integer, Integer>();
int[] someSortedArray = new int[10];

//fill up a sorted array
for(int index = 0; index < someSortedArray.length; index++)
{
    someSortedArray[index] = index+1;
}

int current = someSortedArray[0];
int count = 1;
for(int index = 1; index < someSortedArray.length; index++)
{
    if(someSortedArray[index] != current)
    {
        occurances.put(current, count);
        current = someSortedArray[index];
        count = 1;
    }else
    {
        count++;
    }
}

System.out.println(occurances);

Answer 4

我认为应该这样做（尚未编译）。 你可以在for循环中的任何地方不增加sizeOfArray

// Get the count of instances.
int[] countOfNumbers = new int[50];         // Array to store count
int sizeOfArray = 0;                        // Last position of array filled
int instanceCounter = 1;                    // Counts number of instances
int previousNumber = finalArrayOfNumbers[0]; // Number stored at [k-1]

for (int k=1; k < finalArrayOfNumbers.length; k++) {
    if (previousNumber == finalArrayOfNumbers[k]) {
        instanceCounter++;
    }
    else
    {
       countOfNumbers[sizeOfArray] = instanceCounter;
       instanceCounter = 1; 
       sizeOfArray++;
       previousNumber = finalArrayOfNumbers[k]
    }
 }

 countOfNumbers[sizeOfArray] = instanceCounter;