java - 如何压缩数组，以便不会出现连续的两个或多个值并被该一个值替换

Question

 /**
     * squeeze() takes an array of ints. On completion the array contains the
     * same numbers, but wherever the array had two or more consecutive
     * duplicate numbers, they are replaced by one copy of the number. Hence,
     * after squeeze() is done, no two consecutive numbers in the array are the
     * same.
     * 
     * Any unused elements at the end of the array are set to -1.
     * 
     * For example, if the input array is [ 4 , 1 , 1 , 3 , 3 , 3 , 1 , 1 ], it
     * reads [ 4 , 1 , 3 , 1 , -1 , -1 , -1 , -1 ] after squeeze() completes.
     * @param ints
     *            the input array.
     */
    public static void squeeze(int[] ints) {
         // TODO: Fill in your solution here. Ours takes linear time and is less than 10 lines long,
        // not counting blank/comment lines or lines already present in this file.
       // ArrayList<Integer> k = new ArrayList<Integer>();

下面是我的代码，但由于某种原因逻辑不正确，它返回传递给函数的相同数组，而不是修改后的数组，我相信大多数逻辑是正确的，除非 continue 语句中有错误。每当数组中出现连续的相同索引时，就应该将其替换为该索引

        int deleted = 0;
        int i = 0;
            for(int j = 1; j < ints.length; j++) {  ?
                if(ints[i] == ints[j]) {
                    deleted++;
                    continue;
                }else {
                    //k.add(ints[i]);
                    i++;
                }
            }
            ints = new int[ints.length + deleted];
            for(int s = 0; s < ints.length; s++) {
                if(ints[s] == 0) {
                    ints[s] = -1;
                }
            }
    }

    /**
     * main() runs test cases on your squeeze() method. Prints summary
     * information on basic operations and halts with an error (and a stack
     * trace) if any of the tests fail.
     */

Answer 1

继续只是跳到 for 循环的末尾，跳过任何代码。也就是说，它开始下一次交互。 正如注释中指出的，您需要修改传入的数组，因为定义的方法中没有返回值。 考虑以下因素......

    int deleted = 0;
    for(int j = 0; j < (ints.length-1); j++) {  
        if (ints[j] == -1) // if -1 then we've reached the end of the original list
            break; // this breaks out of the loop even if the constraint is not met

        if(ints[j] == ints[j+1]) { // if consecutive entries are equal
           // shift all values down in the list
           for (int k = j+1; k < (ints.length-1); k++){
               ints[k] = ints[k+1];
           } // end loop k

           // set the last entry in the array to -1 since we moved everything down
           ints[ints.length-1] = -1;

           //back our loop up one so that we stay where we were in case there was 
           // more than two consecutive numbers that were the same
           j--; 
        }
    } // end loop j

    // display the result
    for (int i = 0; i < ints.length; i++)
        System.out.print(ints[i] + ", " );