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

将列表的第一项保存在您的临时文件中。遍历所有项目并检查另一个项目是否等于您的温度。如果没有相同的项目，则将列表的下一项保存在您的临时文件中。否则临时字符串是您的第一个非重复字符串！

于 2013-08-23T06:42:06.083 回答
1

The above code is working now perfectly for me 

package com.test.spaient.sorting;

import java.util.ArrayList;
import java.util.List;

public class TestDuplciate {
public static void main(String[] args) {

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

    String index = null;
    int temp = 0;
    for (int i = 0; i < myList.size(); i++) {


        index = myList.get(i);

        for (int j = 0; j < myList.size(); j++) {
            if (i != j) {
                if (index.equals(myList.get(j))) {
                    index = null;
                    break;

                }
            }
        }
              if (index != null) {
            System.out.println("non duplicate " + index);
        }

        }

    }
   }

Thank you for the guidance

于 2013-08-28T12:20:36.137 回答
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

归类为变量的内容有点模棱两可（我相信整数和迭代器都是变量，但大多数其他答案似乎不同意），我假设它是任何需要声明的东西，即超出了单个语句的范围（整数，迭代器, element, 不管）（所以你可以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和添加getNextWithoutIncrement()函数将允许您删除sif 语句并将其更改为：

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


如果重复的元素没有一个接一个，这就有点问题了。我知道的每个排序算法都使用多个变量（甚至是冒泡排序，也有两个变量）。但是，如果您被允许修改列表，则可以使用修改后的类似冒泡排序的过程，如下所示：

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

nowremove可能不允许，但应该可以通过更改i为Iterator具有附加getNextWithoutIncrement功能的 an 来实现。

又s是另一个变量，但它又是迭代的局部变量，所以它可能没问题。这是 swap 的一个 hacky 替代方法（假设 String 不包含|）：

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

首先，您可以使用 Collection.sort() 方法对其进行排序。
现在您可以线性比较元素。它会更有效率。
因为如果它与下一个元素不匹配，那么它不能与任何其他元素匹配。
该算法的效率为 O(nlog(n))。
nlog(n) 用于排序 & n 以查找重复项。

于 2013-08-23T07:01:03.080 回答
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 个或更多非重复项。

使用单变量的其他方法：

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 回答