0

重複していない配列リスト内の文字列要素を見つける必要があるシナリオがあります 

  List<String> myList=new ArrayList<String>();
  myList.add("abcd");
  myList.add("xyz");
  myList.add("xyz");
  myList.add("pqrs");     
  myList.add("pqrs");

そして私の答えは "abcd" でなければなりません。コレクションAPIを使用せずに、一時変数を1つ使用するだけで、この回答を見つける必要があります。誰でもこれについて私を助けることができますか？

4

7 に答える 7

4

リストの最初の項目を temp に保存します。すべてのアイテムを繰り返し、別のアイテムが一時に等しいかどうかを確認します。等しいアイテムがない場合は、リストの次のアイテムを一時的に保存します。それ以外の場合、一時文字列は最初の重複していない文字列です!

于 2013-08-23T06:42:06.083 に答える
1

これを試してみてくださいが、うまくいきます -

int index=0;
for (int i=0;i<myList.size();i++) {
     for (int j=0;j<myList.size();j++) {
         if(i!=j && myList.get(i).equals(myList.get(j))){
             index++;
             break;
         }
     }
     if(index==0)
          System.out.println("No Duplicate Found -> "+myList.get(index));
     index=0;
}

スループットO(n*n)は最悪になります。

于 2013-08-23T06:48:05.187 に答える
0 
  int count=0;
    for (int i=0;i<myList.size();i++)
     { count=0;
           v=myList.get(i);
          for (int j=0; j<myList.size();j++)
        {
           if (i!=j&&v.equals(myList.get(j)))
                {
                  count++;
                  break ;
                }       
        }   
        if (count==0)
        {
            System.out.println("No duplicate"+""+v);
        }     
    }
于 2013-08-23T07:01:28.343 に答える
0

変数として分類されるものは少しあいまいです (整数とイテレータは変数だと思いますが、他のほとんどの回答は同意しないようです)。宣言が必要なもの、つまり単一のステートメント (整数、イテレータ) の範囲を超えていると仮定します。 、要素、何でも）（したがってget(i).equals(...)、変数として分類せずに行うことができますが、そうするとvar = get(i); var.equals(...)、それは変数になります）。

以下は、繰り返される要素が互いに続くと仮定し、重複を正確に 2 回の出現として分類します。4 回のオカレンスは 2 組の重複として分類され、6 回のオカレンスは 3 組として分類されます。

static String findUnique(Iterable<String> collection)
{
   Iterator<String> iterator = collection.iterator();
   while (iterator.hasNext())
   {
      String s = iterator.next();
      if (!iterator.hasNext() || !s.equals(iterator.next()))
         return s;
   }
   return null;
}

以下を使用して実行できます。

List<String> myList = Arrays.asList("abcd", "xyz", "xyz", "pqrs", "pqrs");
System.out.println(findUnique(myList));

技術的sには別の変数ですが、反復に対してローカルであるため、問題ない可能性があります。それ以外の場合は、関数を変更Iteratorして追加すると、if ステートメントをgetNextWithoutIncrement()削除して次のように変更できます。s

if (!iterator.getNextWithoutIncrement().hasNext() ||
    iterator.next().equals(iterator.next()))


繰り返される要素が互いに続かない場合、これは少し問題です。私が知っているすべてのソート アルゴリズムは、1 つ以上の変数を使用します (バブル ソートでさえ、2 つの変数で行われます)。ただし、リストの変更が許可されている場合は、次のように変更されたバブル ソートのようなプロセスを使用できます。

static String findUnique(List<String> collection)
{
   while (collection.size() > 0)
   {
      int i;
      for (i = 0; i < collection.size()-1; i++)
         if (collection.get(i).equals(collection.get(i+1)))
            break;
         else
         {
            String s = collection.get(i);
            collection.set(i,collection.get(i+1));
            collection.set(i+1,s);
         }
      if (i == collection.size()-1)
         return collection.get(collection.size()-1);
      else
      {
         collection.remove(i);
         collection.remove(i);
      }
   }
   return null;
}

電話：

List<String> myList= new ArrayList<String>(Arrays.asList("xyz", "abcd", "xyz", "pqrs", "pqrs"));
System.out.println(findUnique(myList));

今removeは無理かもしれませんが、機能を追加しiたものに変更すればできるはずです。IteratorgetNextWithoutIncrement

またs別の変数ですが、これも反復に対してローカルであるため、問題ない可能性があります。これは swap のちょっとしたハックな代替手段です (文字列に が含まれていないと仮定します|):

collection.set(i, collection.get(i+1) + "|" + collection.get(i));
collection.set(i+1, collection.get(i).substring(collection.get(i).indexOf("|") + 1));
collection.set(i, collection.get(i).substring(0, collection.get(i).indexOf("|")));
于 2013-08-23T09:30:13.690 に答える
0 
public class TestDuplicate {

    /**
     * @param args
     */
    static List<String> list = new ArrayList<String>(0);
    private static String[] skipElements;
    public static void main(String[] args) {
        
        list.add("Test");
        list.add("xyz");
        list.add("xyz");
        list.add("pqrs");
        list.add("pqrs");
        list.add("abcd");
        skipElements = new String[list.size()];
        
        for(int i = 0; i < list.size() ; i++){
            if(isDuplicate(list.get(i), i)){
                skipElements[i] = list.get(i);
            }
        }
        removeAllDuplicate();
        System.out.println("Non Duplicates are-->"+ list);

    }
    private static boolean isDuplicate(String element, int index){
        for(int i = index+1; i < list.size(); i++){
            if(checkExistance(element) ){
                return Boolean.TRUE;
            }else{
                
                if(element.equalsIgnoreCase(list.get(i))){
                    return Boolean.TRUE;
                }
            }
        }
        return false;
    }
    private static boolean checkExistance(String element){
        for(int i = 0 ; i < skipElements.length ; i++){
            if(element.equalsIgnoreCase(skipElements[i])){
                return Boolean.TRUE;
            }
        }
        return Boolean.FALSE;
    }
    
    private static void removeAllDuplicate(){
    for(int i = 0; i < skipElements.length; i++){
        if(skipElements[i] != null){
            
            removeFromList(skipElements[i]);
        }
    }
}
private static void removeFromList(String element){
    if(list.contains(element)){
        list.remove(element);
        removeFromList(element);
    }
}

}

これにより、文字列のリストから 0 個以上の非重複が得られます。

Singel 変数を使用したその他のアプローチ:

2:

public class TestDuplicateWithOneVariable {

    /**
     * @param args
     */
    static List<String> list = new ArrayList<String>(0);
    private static int stop = 0;
    public static void main(String[] args) {
        
        
        list.add("xyz");
        list.add("xyz");
        list.add("xyz");
        list.add("pqrs");
        list.add("pqrs");
        list.add("abcd");
        list.add("Test");
        
        while(stop >= 0){
            
            if(list.size() > 0 && list.size() > stop){
                if(isDuplicate(list.get(stop))){
                    removeFromList(list.get(stop));
                }
            }else{
                stop = -1;
            }
            
            
        }
        System.out.println("Non Duplicate-->"+list);
    }
    
    private static void removeFromList(String element){
        if(list.contains(element)){
            stop = 0;
            list.remove(element);
            removeFromList(element);
        }
    }
    
    private static boolean isDuplicate(String element){
        list.remove(element);
        if(list.contains(element)){
            return Boolean.TRUE;
        }else{
            list.add(stop,element);
            stop++;
            return Boolean.FALSE;
        }
    }

}
于 2013-08-23T09:08:37.787 に答える
0

まず Collection.sort() メソッドを使用してソートできます。
要素を直線的に比較できるようになりました。それはより効率的になります。
次の要素と一致しない場合は、それ以上他の要素と一致してはならないためです。
このアルゴリズムの効率は O(nlog(n)) になります。
nlog(n) はソート & n は重複を見つけるためのものです。

于 2013-08-23T07:01:03.080 に答える