获得n个String数组相同元素算法？
假设有5个字符串数组，每个有100个元素，要获得这5个数组中都包含的元素的个数怎么写呢？
例:
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 "};
这五个数组的相同元素为2个。
[解决办法]
先想到个最慢的方法，for嵌套，选中一个，然后遍历其他的。
应该还有更好的方法，thinking......
[解决办法]
求出长度最小的数姐，以长度最小数组元素为基数，
初始化一个整型变量比如n,
比较其余数组，相同刚输出，n++;
大概就这样，参考下
[解决办法]
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]于其他数组比较，按照这个规律循环。
[解决办法]
说个我自己的思路:(针对数组中没有重复元素)
如果每个数组中元素都不重复,那么只需要,统计每个元素出现的次数,记下那些元素出现次数等于5的倍数,这样是不是就找到了那些元素呢
-_-#
[解决办法]
先比较数组长度最小的
再用得到的结果去比较次小的，一直到数组长度最大的。
不知道有没有更好的方法。
是字符数组就不好弄了，如果是整型数组倒有好的算法。
[解决办法]
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为结果。
[解决办法]
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纪录相同的个数
[解决办法]
用个hashtable搞定。。。。
[解决办法]
map + 5次循环遍历就可以了.
[解决办法]
这个问题显然可以简化为，首先判断数组的长度，取长度最短的作为比较的对象，不用每个都比较
[解决办法]
本人初学,用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]