Удаление дубликатов из массива в Java

Question

У меня есть массив типа long, и я просто пытаюсь создать код, который найдет и удалит дубликаты. Это несколько работает, но в нем есть некоторые ошибки. Я не уверен, что я делаю неправильно. Я очень благодарен за помощь.

Я добавил число: 77, 44, 22, 11, 66, 33, 55, 55, 99, 99, 33, 0, 0

и выход: 77, 44, 22, 11 , 66, 33, 55, 55, 99, 99

так стерли 33 дубликата и оба 0 и полностью пропущено 55 и 99.

Вот мой код до сих пор:

nElems является размер матрицы

public int noDups() 
{ 
    int duplicates = 0; 

    for(int i = 0; i<nElems; i++) 
    { 
     for(int j = i+1; j<nElems; j++) 
     { 
      if(i == j) 
      { 
       break; 
      } 
      else if (a[i] == a[j]) 
      { 
       duplicates++; 
       delete(j); 
       nElems--; 
      } 
     }// end for j 
     }// end for i 

    return duplicates; 

}// noDups() 

Мои Удалять выглядит следующим образом:

public boolean delete(long value) 
{ 
    int j; 

    for(j=0; j<nElems; j++) // look for it 
    { 
     if(value == a[j]) 
      break; 

     if(j==nElems) // can’t find it 
      { 
      return false; 
      } 
     else // found it 
      { 
      for(int k=j; k<nElems; k++) // move higher ones down 
       { 
        a[k] = a[k+1]; 
        nElems--; // decrement size 
        return true; 
       } 
      } 
    }// end for i 
} // end delete() 

Answer 1

public static class Node { 
     int value; 
     Node next; 
     Node prev; 

     public Node(int value) 
     { 
      this.value = value; 
     } 
    } 

    public static class List { 
     Node[] list = new Node[32]; 
     int size = 0; 

     public void put(int value) { 
      int index = value & 31; 
      for (Node n = list[index]; n != null; n = n.next) { 
       if (n.value == value) { 
        return; 
       } 
      } 

      Node newNode = new Node(value); 
      Node n = list[index]; 
      if (n != null) { 
       n.prev = newNode; 
       newNode.next = n; 
      } 
      list[index] = newNode; 
      size++; 
     } 

     public void addAll(int[] array) { 
      for (int x = 0; x < array.length; x++) { 
       put(array[x]); 
      } 
     } 

     public int[] toArray() { 
      int[] array = new int[size]; 
      if (size != 0) { 
       main: 
       for (int b = 0, i = 0; b < list.length; b++) { 
        Node n = list[b]; 
        for (; n != null; n = n.next) { 
         // Place this value in to our array. 
         array[i++] = n.value; 
         // We break because our index is larger than our 
         // available array size. 
         if (i >= size) { 
          break main; 
         } 
        } 
       } 
      } 
      return array; 
     } 
    } 

    public static void main(String[] args) { 
     List list = new List(); 
     int[] array = new int[] {77, 44, 22, 11, 66, 33, 55, 55, 99, 99, 33, 0, 0}; 
     list.addAll(array); 
     System.out.println(Arrays.toString(list.toArray())); 
    } 

писал этот код для вас. Будет делать все, что вам нужно, и очень быстро!

Answer 2

В noDups j - это позиция в индексе. Вы вызываете delete (j), но ваш метод удаления ожидает значение, а не позицию. Вам нужно изменить тот или иной (и использовать позицию, а не значение, вероятно, ваш лучший вариант).

Answer 3

Ваша проблема заключается в методе удаления. Попробуйте передать ему индекс массива (так как j - ваш дубликат в массиве, попробуйте j). В пределах вашего удаления удалите этот индекс, переопределив его с помощью индексов, проходящих мимо него в массиве. Для того, чтобы удалить его просто:

for(int i = j; i<a.length - 1; i++){ 
    a[i] = a[i+1]; 
} 

, а затем установить a.length обнулить

a[a.length] = null; 

Это только если они имеют нулевые значения в массиве в порядке, если нет, то вам нужно создать новый массив, сохраняет все в массиве до j, а затем из j в магазинах j + 1. Затем ему нужно будет вернуть его или вам нужно будет установить новый массив. Причина, по которой это a.length - 1, состоит в том, что если вы делаете только a.length, она будет проходить до конца вашего массива и попытаться установить последнее значение на неизвестное значение из индекса. Это не лучшее решение, но это решение, предполагающее, что вы должны работать с циклом через массивы и не использовать Java-классы.

Answer 4

Я думаю, что ответы более усложняют вашу домашнюю работу. Самое простое решение заключается в следующем:

//noDoup partial code 
if (list[i] == list[j]) 
{ 
    duplicates++; 
    delete(j); 
    nElems--; 
    j--;//you missed this 
} 
//delete() is simply this 
public boolean delete(long value) 
{ 
    System.arraycopy(list, j+1, list, j, nElems-j-1); 
} 

Полученный массив Arrays.copyOf(list, nElems);

Answer 5

Я должен был сделать это для присвоения класса и не нравились ответы здесь. Они были либо слишком сложными, либо слишком простыми и неэффективными. Мне нравится иметь золотую середину, так что я бросил это вместе:

public static int[] exercise6(int[] array) { 
    int del = 0; 
    for(int i = 0; i < array.length - (1 + del); ++i) { 
     for(int j = array.length - (1 + del); j > i; --j) { 
      if(array[i] == array[j]) { 
       for(int k = j; k < array.length - (1 + del); ++k) { 
        array[k] = array[k + 1]; 
       } 
       array[array.length - 1] = 0; 
       del++; 
      } 
     } 
    } 
    return Arrays.copyOfRange(array, 0, array.length - del); 

Если вам не нужно укоротить сам массив, который вы всегда можете просто вернуть массив вместо.

Answer 6

public class Arrayremoveduplicates { 
    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     String[] Origarray = { "10", "20", "30" }; 
     System.out.println("Original array with duplicates :"); 
     for (int a = 0; a < Origarray.length; a++) { 
      System.out.print(Origarray[a] + " "); 
     } 
     System.out.println(); 
     System.out.println("Result array without duplicates :"); 
     for (int i = 0; i < Origarray.length; i++) { 
      int duplicate = 0; 
      for (int j = i + 1; j < Origarray.length; j++) { 
       if (Origarray[i] == Origarray[j]) { 
        duplicate = duplicate + 1; 
       } 
      } 
      if (duplicate == 0) { 
       System.out.print(Origarray[i] + " "); 
      } 
     } 
    } 
} 

Answer 7

private Map<Integer, Integer> getUniqueArray(int[] duplicateArray) { 
    Map<Integer, Integer> uniqueMap = new HashMap<>(); 
    int count = 0; 
    for (int element : duplicateArray) { 
     count = 0; 
     if (uniqueMap.get(element) != null) { 
      ++count; 
     } 
     if (count == 0) { 
      uniqueMap.put(element, count); 
     } 
    } 
    return uniqueMap; 
} 

Answer 8

пакет ком.sparity; импорт java.util. *;

класса RemoveDuplicates {

public static void main(String[] args) { 
    Integer[] array = new Integer[10]; 

    array[0] = 1; 
    array[1] = 2; 
    array[2] = 3; 
    array[3] = 3; 
    array[4] = 3; 
    array[5] = 3; 
    array[6] = 7; 
    array[7] = 7; 
    array[8] = 9; 
    array[9] = 9; 
    removeDuplicatesFromArray(array); 

} 


private static void removeDuplicatesFromArray(Integer[] array){ 
    StringBuffer stringBuffer = new StringBuffer(); 
    String arrayString = Arrays.toString(array); 
    for(int index =0 ; index <= arrayString.length(); index++){ 
     try{ 
      int number = Integer.parseInt(arrayString.charAt(index)+""); 
      if(!stringBuffer.toString().contains(number+"")){ 
      if(stringBuffer.length()!=0) 
       stringBuffer.append(","); 
      stringBuffer.append(number); 
      } 

     }catch(Exception e){ 

     } 
    } 
    String[] stringArray = stringBuffer.toString().split(","); 
    array = new Integer[stringArray.length]; 
    for(int index = 0 ; index < stringArray.length ; index++){ 
     array[index] = Integer.parseInt(stringArray[index]); 
    } 
    System.out.println(Arrays.toString(array)); 
    } 

}