从数组中删除重复项（没有集合或排序）

Question

我有以下代码：

import java.util.Scanner;
public class ArrayDuplicates {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("How many numbers are you going to enter? ");
        int num = scan.nextInt();
        int[] arr = new int[num]; // initialize array with user inputted length
        for (int i = 0; i < arr.length; i++) { // enter numbers into array
            arr[i] = scan.nextInt();
        }

        int[] unique = new int[arr.length];    //initialize new array that will hold unique values
        for (int i = 0; i < arr.length; i++) {
            boolean b = true;    //boolean that checks if an element is a duplicate
            for (int j = i+1; j < arr.length; j++) {    //check all elements above int i
                if (arr[i] == arr[j]) {
                    b = false;    // set b to false if there is an existing duplicate
                }
            }
            if (b) {
                unique[i] = arr[i];    // if no duplicates exist, then it is unique.
            }
        }   
        for (int i = 0; i < unique.length; i++) {
                System.out.println(unique[i]);
        }
    }
}

这段代码的问题（除了对于大型数组来说非常慢，但这不是重点）是因为 unique 数组的未声明元素将被设置为 0，第一个中的重复元素数组在unique[] 中被设置为0（如果有任何意义的话）。我理解为什么会发生这种情况，但找不到解决此问题的有效方法。我尝试在唯一数组中将重复元素设置为Integer.MIN_VALUE，然后只打印不等于Integer.MIN_VALUE 的unique[] 的元素，但这似乎是解决问题的一个弱解决方案。我该如何解决这个问题？

编辑：如果我运行代码：

你要输入多少个数字？ 4
1
2
2
0

输出：

1
0
2
0

由于数组的第二个元素是重复的，我没有将unique[1] 设置为任何值，使其默认为 0。如何避免打印该 0，因为它不是原始数组的一部分？

编辑 2： 是的，这是作业，但我不想使用集合、排序等的原因主要是我不熟悉它们。另外，由于我没有要求任何人为我编写整个程序，所以我认为寻求一点帮助是可以的。

Answer 1

您选择的任何值（零、最小整数、最大整数）来表示已删除的重复项都是一个问题。用户总是可以输入该数字，而您的程序将无法正常运行。 （您可以合法使用（例如）min-int 或 max-int 的唯一方法是，如果要求明确说明该数字是无效输入。）

处理重复的正确方法是保留非重复数量的计数器，并确保重复（或包含它们的插槽）位于数组的高端；即索引> =计数器。 （这成为您的算法需要维护的不变量......）

最好的解决方案是在将重复项添加到数组之前消除它们。记录非重复项的数量并进行迭代，直到达到您的 num ... 而不是数组的长度。

但是，如果您确实想将所有值添加到数组中并然后消除重复项，那么当您发现重复项时，您需要交换元素以便保持不变量。逻辑有点繁琐......但非常可行。

更新

我刚刚注意到您最初的解决方案是使用两个数组。我假设您使用的是一个数组，并进行就地更新以消除重复项。

Answer 2

我将使用你用来解决问题的工具，因为我的某些东西告诉我这是家庭作业...

import java.util.Scanner;

public class ArrayDuplicates 
{

   public static void main(String[] args) 
   {

      Scanner scan = new Scanner(System.in);

      System.out.print("How many numbers are you going to enter? ");
      int num = scan.nextInt();

      int[] arr = new int[num]; // initialize array with user inputted length

      for (int i = 0; i < arr.length; i++)// enter numbers into array
      {

         arr[i] = scan.nextInt();

      }

      double[] unique = new double[arr.length];    //initialize new array that will hold unique values

      ///////My edit

      for(int z = 0; z < unique.length; z++)
      {

         unique[z] = -0.5;

      }

      ///////

      for (int i = 0; i < arr.length; i++) 
      {

         boolean b = true;    //boolean that checks if an element is a duplicate

         for (int j = i+1; j < arr.length; j++)    //check all elements above int i
         {

            if (arr[i] == arr[j]) 
            {

               b = false;    // set b to false if there is an existing duplicate

            }

         }

         if (b) 
         {

            unique[i] = arr[i];    // if no duplicates exist, then it is unique.

         }

      }   

      for (int i = 0; i < unique.length; i++) 
      {

         if(!(unique[i] == -0.5))
         {

            System.out.println((int)(unique[i]));

         }

      }

   }
}

那么，你看到我在哪里注释掉了我的编辑吗？这是新事物，一个非常简单的检查方法是给值一个不预期的数字，在这种情况下，是一个负数。现在，这是我的一个假设，将 -1 更改为您知道将不会输入到 Scanner 的任何值。 if 语句也一样。

Answer 3

最好的方法是使用Map。

public interface Map<K,V>

将键映射到值的对象。地图不能包含重复项 钥匙；每个键最多可以映射到一个值。

我不知道你为什么不想使用一套，除非你在做作业......

---

如果你真的不能使用一套。继续创建ArrayList。将array 的元素存储在其中，但每次要存储时，请检查该元素是否已经是ArrayList 的一部分。

 int [] list = {5, 5, 3, 2, 5, 3, 5};

 ArrayList<Integer> list2 = new ArrayList<Integer>();

 for(int i = 0; i < list.length; i++)
    if(!list2.contains(list[i]))
        list2.add(list[i]);

如果需要，您可以将 ArrayList 转回数组。

Object[] list3 = list2.toArray();

Answer 4

您可以存储用户输入的最大值（当用户在第一个循环中输入值时），然后使唯一性的默认值等于 max + 1。

或者您可以尝试另一种解决问题的方法，如下所示：

  int num = scan.nextInt();
  int[] arr = new int[num];
  int[] uniq = new int[num+1000000];
  int j = 0;

  // enter numbers into array
  for (int i = 0; i < arr.length; i++) { 
     int input = scan.nextInt(); 
     if(uniq[input] != 1){
         uniq[input] = 1;  
         arr[j] = input;
         j++;
      }
   } 

   for (int i = 0; i < j; i++) {
      System.out.println(arr[i]);
   }

请注意，此解决方案假设用户不会输入大于(num + 1,000,000) 的数字。

Answer 5

此解决方案允许您输入任何整数值，甚至是负数。这是您的相同代码，并进行了一些修改，并添加了一个并行数组进行比较。它还删除了一些不再需要的代码行。

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.print("How many numbers are you going to enter? ");
    int num = scan.nextInt();
    int[] arr = new int[num]; // initialize array with user inputted length
    int[] arrflag = new int[num];
    for (int i = 0; i < arr.length; i++) { // enter numbers into array
        System.out.print("Enter number: ");
        arr[i] = scan.nextInt();
        arrflag[i] = 0;
    }

    int[] unique = new int[arr.length];    //initialize new array that will hold unique values
    int n=0;
    for (int i = 0; i < arr.length; i++) {            
        if (arrflag[i] == 0) {
            unique[n++] = arr[i];
            for (int j = i+1; j < arr.length; j++) {    //check all elements above int i
                if (arr[i] == arr[j]) {                        
                    arrflag[j]=-1;
                }
            }                
        }
    }   
    for (int i = 0; i < n; i++) {
            System.out.println(unique[i]);
    }
}

Answer 6

创建一个所有值都为“.”的并行字符数组每当您找到重复项时，将值设置为字符数组中的“，”。然后仅打印具有相应“。”的数组的值。在字符数组中。

 }
    System.out.println();
    for (int i = 0; i < arr.length; i++) {
        if(a[i]=='.')
            System.out.println(arr[i]);
    }
}

}

Answer 7

字符串 [] 示例。

public static List<String> arrListWithNoDups(String arr[]){

    Map<String, Integer>map = new HashMap<String, Integer>();
    List<String>list = new ArrayList<String>();

    for(int i = 0; i<arr.length; i++){
        if(map.get(arr[i]) == null){
            map.put(arr[i], 0);
        }
        else{
            map.put(arr[i], map.get(arr[i])+1);
        }
    }

    for(int j = 0; j<arr.length; j++){
        if(map.get(arr[j])==0){
            list.add(arr[j]);
        }
    }

    return list;

}

Answer 8

公共类 RemoveDuplicateFromArray {

public static void main(String[] args) {

    int[] myArray = {1, 2, 1, 4, 1, 5, 2, 5};
    System.out.println("Before removing duplicate" + Arrays.toString(myArray));

    RemoveDuplicateFromArray rd = new RemoveDuplicateFromArray();
    int[] newArray = rd.findDuplicate(myArray);
    System.out.println("Before removing duplicate" + Arrays.toString(newArray));
}

public int[] findDuplicate(int[] inputArray) {
    Arrays.sort(inputArray);
    int count = 0;
    for (int i = 0; i < inputArray.length; i++) {
        if (i + 1 < inputArray.length && inputArray[i] == inputArray[i + 1]) {
            count++;
        }
    }
    int[] result = new int[inputArray.length - count];
    int c = 0;
    for (int j = 0; j < inputArray.length; j++) {
        if (j + 1 < inputArray.length && inputArray[j] == inputArray[j + 1]) {

        } else {
            result[c] = inputArray[j];
            c++;
        }
    }
    inputArray = result;
    return inputArray;
}

}

Answer 9

我尝试改进此代码，如果可以进一步改进，请 cmets/suggest。

public static int[] removeDuplicate(int[] arr) {
    int[] noDuplicates = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        boolean b = true;

        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]){
                b = false;
            }
        }

        if (b) {
            noDuplicates[i] = arr[i];
            System.out.print(noDuplicates[i] + " ");
        }
    }
    return noDuplicates;

}

Answer 10

void myFunction(int arr[])
{

    int size=arr.length;
    for(int i=0;i<size;i++)
    {
        for(int j=i+1;j<size;j++)
        {

            if(arr[i]==arr[j])
            {
                arr[j]=arr[size-1];
                size--;
            }
        }
    }

    for(int a=0;a<size;a++)
    {
        System.out.print(arr[a]+" ");
    }

}