获得n个String数组相同元素算法？

先想到个最慢的方法，for嵌套，选中一个，然后遍历其他的。应该还有更好的方法，thinking......

import java.util.ArrayList;
import java.util.List;
public class Test2 {
public static void main(String[]str) {
String[] a ={"1","33","55","67"};
String[] b ={"1","56","97","111","33"};
String[] c ={"1","11","22","33"};
String[] d ={"1","33"};
String[] e ={"1","2","3","33"};

ArrayList list = new ArrayList();
list.add(a);
list.add(b);
list.add(c);
list.add(d);
list.add(e);

System.out.println(new Test2().find(list).size());
}

public List find(List list) {
String[]strArray1 = (String[]) list.get(0);
List arrList = new ArrayList();
for (int i = 0; i < strArray1.length; i++) {
arrList.add(strArray1[i]);
}

for (int i = 1; i < list.size() - 1; i++) {
String[]strArray2 = (String[]) list.get(i);
arrList = compare(arrList, strArray2);
}
return arrList;
}

public List compare(List a, String[] b) {
List resultList = new ArrayList();
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < a.size(); j++) {
if (a.get(j).equals(b[i])) {
resultList.add(a.get(j));
break;
}
}
}
return resultList;
}
}

可不可以先放到集合里面。然后再研究一下这个方法retainAll(Collection<?> c)

public class Test
{
    static String[] strcomp(String[] s1, String[] s2)
    {
        if(s1.length <= s2.length)
            return s1;
        else
            return s2;
    }

    static String[] strcompR(String[] s1, String[] s2, String[] s3, String[] s4, String[] s5)
    {
        return strcomp(strcomp(strcomp(strcomp(s1, s2), s3), s4), s5);
    }

    static boolean comp(String s, String[] a)
    {
        boolean k = true;
        for(String i : a)
        {
            if(i == s)
            {
                k = true;
                break;
            }
            else
                k = false;
        }
        return k;
    }

    public static void main(String[] args)
    {
        String[] a ={"1","33","55","67"};
        String[] b ={"1","56","97","111","33"};
        String[] c ={"1","11","22","33"};
        String[] d ={"1","33"};
        String[] e ={"1","2","3","33"};

        String[] t = strcompR(a,b,c,d,e);

        for(String i : t)
        {
            if(comp(i, a)&&comp(i, b)&&comp(i, c)&&comp(i, d)&&comp(i, e))
                System.out.println(i);
        }
     }
}

求出长度最小的数组X，以长度最小数组元素为基数k,记录个数为n;用X[0]和其他数组(按数组小-〉大)比较，如果有，n++；如果没有，则X[1]于其他数组比较，按照这个规律循环。

jianghuxiaoxiami(江湖小虾米) ( ) 信誉：100    Blog   加为好友  2007-4-20 17:16:36  得分: 0

说个我自己的思路:(针对数组中没有重复元素)如果每个数组中元素都不重复,那么只需要,统计每个元素出现的次数,记下那些元素出现次数等于5的倍数,这样是不是就找到了那些元素呢-_-#
---------------
如果没有相同,那上面的应该可以吧

都放到HashSet里面，用（hashset.size()-五个数祖总长度）/4就是答案了吧

jdk1.5里在java.util.Arrays里不是新增了deepEquals方法了吗？
直接调用不就行了

谢谢大家的帮助。
jiqi62120() 写的倒是可以，不知道有没有更好的算法呢回jianghuxiaoxiami(江湖小虾米) ：你的思路是不错，不过要是数组中元素很多的话也很难实现啊。
回zzwh_0() :不明白啊
回weijieut() ：不好意思我现在用的是1.4

j2se 1.4阿要换新版本拉

LZ看看我写的这个，比较的方法都用的是JDK中的现成的方法。
思路和大家差不多，就是循环数组长度最小的，来对比其它的数组，只不过把它们按长度从小到大排序了。总是先比较长度最小的，如果没有，直接跳出，后边的都不用再比较了。
　　　　　　　　　　　　　程序如下：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;public class CSDN { /**
* @param args
*/
@SuppressWarnings("unchecked")
public static void main(String[] args) {
// TODO Auto-generated method stub String[] a = { "1", "33", "55", "67" };
String[] b = { "1", "56", "97", "111", "33" };
String[] c = { "1", "11", "22", "33" };
String[] d = { "1", "33" };
String[] e = { "1", "2", "3", "33" }; // 创建一个List,把已知数组也转为List类型并加入
ArrayList<List<String>> list = new ArrayList<List<String>>(); list.add(Arrays.asList(a));
list.add(Arrays.asList(b));
list.add(Arrays.asList(c));
list.add(Arrays.asList(d));
list.add(Arrays.asList(e)); // 创建一个Comparator,按从小到大的顺序
class Mycomparator implements Comparator {
public int compare(Object o1, Object o2) {
List l1 = (List) o1;
List l2 = (List) o2;
if (l1.size() < l2.size())
return 0;
else
return 1;
}
}
Comparator comp = new Mycomparator(); // 把list中元素所包含元素数（其实就是已知各数组的长度）按从小到大排序
Collections.sort(list, comp);
if (list.size() > 0) {
// 若list中有元素（这里是肯定有的）,取出第一个（已知数组长度最小的）
List min = list.get(0);
int result = 0;
for (int i = 0; i < min.size(); i++) {
// 用n来记录有多少个元素（已知数组转换的List）包含
int n = 0;
// 循环从第二个开始，判断是否包含第一个中的元素
for (int j = 1; j < list.size(); j++) {
List li = list.get(j);
if (!li.contains(min.get(i))) {
// 若不包含，直接跳出，以后的都不用比较了
break;
} else {
// 若包含，n++
n++;
}
}
if (n == list.size() - 1) {
// 如果都包含，result++，打印出相同的元素
result++;
System.out.println("相同元素: " + min.get(i));
}
}
// 最后打印出相同元素的个数
System.out.println("相同元素的个数为 :" + result);
}
}
}

new一个Map: countString
遍历一边这些字符串，记当前字符串为str;
count = countString.get(str);
if(count == null) count = new Integer(0);
count++;
countString.put(str, count);最后遍历countString：取出相同的key为结果。

Mistake:
最后遍历countString：取出相同的key为结果。
->
最后遍历countString：取出value=5的key为结果。

public class Main {
public static void main(String[] args) {
String[] a ={"1","33","55","67"};
String[] b ={"1","56","97","111","33"};
String[] c ={"1","11","22","33"};
String[] d ={"1","33"};
String[] e ={"1","2","3","33"};

for (int i1 = 0; i1 < a.length; ++i1) {
for (int i2 = 0; i2 < b.length; ++i2) {
for (int i3 = 0; i3 < c.length; ++i3) {
for (int i4 = 0; i4 < d.length; ++i4) {
for (int i5 = 0; i5 < e.length; ++i5) {
if(a[i1].equals(b[i2])&&a[i1].equals(c[i3])&&a[i1].equals(d[i4])&&a[i1].equals(e[i5])) {
System.out.println(e[i5]);
}
}
}
}
}
}
}
}

数组元素既然被初始化为100个元素
如果没降这个数组“填满”的话，剩余的空元素也会被计为相同啊
我的算法是：依次比较，取出两者相同的元素与第三个数组比较
            递归此过程，将所有数组比较完。当然函数本身可以递归也可以不递归
            数组的接口为：
                        string * cmp(string a[],string b[],stirng c[],int cout);
                        a b为被比较对象，存入c中，cout纪录相同的个数

map + 5次循环遍历就可以了.

String[][] strs = {a, b, c, d ,e};
List result = new ArrayList();
for (int i = 0; i < strs[0].length; i++) {
String string= strs[0][i];
boolean flag = true;
for (int j = 1; j < strs.length && flag; j++) {
String[] strings = strs[j];
int k;
for (k = 0; k < strings.length; k++) {
if(string.equals(strings[k]))
break;
}
if(k>=strings.length) flag =false;
}

if(flag) result.add(string);
}
System.out.println("The " + result.size() + " same strings are: ");
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + " \t");
}
=======
output:
The 2 same strings are:
1 33

above: O(n^3)use Map: O(n^2)

Oh, 用map的话可能map.get(key)也会用掉O(n)? 那样时间就差不多了上面这个确实是最基本的了（只用到了一个String的equals方法）

本人初学,用Set实现
import java.util.*;public class Test {
public static void main(String[] args) {

Set<String> s1 = new HashSet<String>();
Set<String> s2 = new HashSet<String>();
Set<String> s3 = new HashSet<String>();
Set<String> s4 = new HashSet<String>();
Set<String> s5 = new HashSet<String>();

String[] a ={"1","33","55","67"};
String[] b ={"1","56","97","111","33"};
String[] c ={"1","11","22","33"};
String[] d ={"1","33"};
String[] e ={"1","2","3","33"};

for (int i=0;i<a.length;i++) {
s1.add(a[i]);
}
for (int i=0;i<b.length;i++) {
s2.add(b[i]);
}
for (int i=0;i<c.length;i++) {
s3.add(c[i]);
}
for (int i=0;i<d.length;i++) {
s4.add(d[i]);
}
for (int i=0;i<e.length;i++) {
s5.add(e[i]);
}

s1.retainAll(s2);
s1.retainAll(s3);
s1.retainAll(s4);
s1.retainAll(s5);

System.out.println(s1.size());
System.out.println(s1);
}
}
输出:
2
[33,1]

String[] a ={"1","33","55","67"};
String[] b ={"1","56","97","111","33"};
String[] c ={"1","11","22","33"};
String[] d ={"1","33"};
String[] e ={"1","2","3","33"};
List list=new ArrayList();
list.addAll(Arrays.asList(a));
list.addAll(Arrays.asList(b));
list.addAll(Arrays.asList(c));
list.addAll(Arrays.asList(d));
list.addAll(Arrays.asList(e));
System.out.println(list);
Map m=new HashMap();
for(Iterator it=list.iterator();it.hasNext();){
String str=(String)it.next();
if(m.containsKey(str)){
int val=((Integer)m.get(str)).intValue();
m.put(str,new Integer(++val));
}else{
m.put(str,new Integer(1));
}
}
System.out.println(m);

调试易

获得n个String数组相同元素算法？

解决方案 »