从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），但是您的delete方法期望值而不是位置。 您需要更改一个或另一个（使用位置而不是值可能是更好的选择）。

Answer 3

您的问题出在删除方法上。 尝试将其传递给数组的索引（因为j是您在数组中的重复项，请尝试j）。 在删除中，通过用数组中过去的索引覆盖该索引来删除该索引。 要简单地删除它：

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

然后将a.length设置为null

a[a.length] = null;

只有在数组中包含null的情况下，这是必须的，否则，您需要创建一个新数组，将数组a中的所有内容存储到j，然后从j存储j + 1。 然后它将需要返回它，或者您需要将a设置为新数组。 它是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 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 6

包比较 导入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));
  }

}

Answer 7

我将使用Map删除重复项，如下所示。

public class RemoveDuplicates {
 public static void main(String args[]) {
    int[] array = { 1, 34, 23, 54, 2, 1, 34, 2 };
    int j = 0;
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < array.length; i++) {
        //true if the current element is already present
        if (!map.containsKey(array[i])) {
            map.put(array[i], array[i]);
        }
    }
    //just print all the elements without converting into array
    System.out.println(map.keySet().toString());
    int[] uniqueElements= new int[map.keySet().size()];
    //Convert keys into array
    for (Integer s : map.keySet()) {
        uniqueElements[j++] = s;
    }
 }
}

Answer 8

我必须在上课时这样做，不喜欢这里的答案。 它们要么过于复杂，要么过于简单和低效。 我喜欢有一个快乐的媒介，所以我把它放在一起：

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 9

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;
}