我有一个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()
答案 0 :(得分：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()));
}
为您编写此代码。将你所需要的一切都做得非常快！
答案 1 :(得分：0)
在noDups中，j是索引中的位置。你正在调用delete（j），但你的delete方法是期望值而不是位置。您需要更改其中一个（并且使用位置而不是值可能是更好的选择）。
答案 2 :(得分：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 + 1的j存储。然后它需要返回它，否则你需要设置一个新的数组。它是a.length - 1的原因是因为如果只执行a.length，它将循环到数组的末尾并尝试将最后一个值设置为索引之外的未知值。这不是最好的解决方案，但假设您应该使用循环数组而不是实际使用Java类，这是一个解决方案。
答案 3 :(得分：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);
答案 4 :(得分：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] + " ");
}
}
}
}
答案 5 :(得分：0)
包com.sparity; import java.util。*;
class 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));
}
}
答案 6 :(得分：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;
}
}
}
答案 7 :(得分：-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);
如果您不需要截断数组本身，则可以始终只返回数组。
答案 8 :(得分：-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;
}