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

パッケージcom.sparity; import 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 
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

あなたの問題は削除方法にあります。配列のインデックスを渡してみてください (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 クラスを使用するのではなく、配列をループ処理することを想定した解決策です。

于 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 に答える
-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 に答える