0

我有一个 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()
4

9 回答 9

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

为你写了这段代码。会做你需要做的一切，而且非常快！

于 2012-05-05T00:34:51.207 回答
0

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

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

然后将 a.length 设置为 null

a[a.length] = null;

仅当数组中有空值是可以的，如果不是，则需要创建一个新数组，将数组 a 中的所有内容存储到 j，然后从 j 开始存储 j+1。然后它需要返回它，或者您需要将 a 设置为新数组。它是 a.length - 1 的原因是因为如果您只执行 a.length，它将循环到数组的末尾并尝试将您的最后一个值设置为索引之外的未知值。这不是最好的解决方案，但它是一个假设您应该使用循环数组而不是实际使用 Java 类的解决方案。

于 2012-05-05T01:09:41.767 回答
0

我认为答案过于复杂了你的作业。最简单的解决方案如下：

//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);

于 2012-05-05T01:10:43.103 回答
0 
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] + " ");
            }
        }
    }
}
于 2013-03-20T06:16:21.900 回答
0

在 noDups 中，j 是索引中的一个位置。您正在调用 delete(j)，但您的 delete 方法需要一个值而不是一个位置。您需要更改其中一个（并且使用位置而不是值可能是您更好的选择）。

于 2012-05-05T00:57:49.183 回答
0

包 com.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));
  }

}

于 2015-10-14T10:42:42.647 回答
0

我将使用 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;
    }
 }
}
于 2018-04-19T06:56:47.000 回答
-1

我不得不为课堂作业做这个并且不喜欢这里的答案。它们要么过于复杂，要么过于简单且效率低下。我喜欢有一个快乐的媒介，所以我把它放在一起：

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

如果您不需要截断数组本身，您可以随时返回数组。

于 2013-01-11T17:38:21.370 回答
-2 
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;
}
于 2013-10-05T12:51:26.137 回答