大家好，我现在有这么个需求，就是我有一个数组，如果里面的值全都相同，我就得到这个数值，以及数组元素全部索引，如果数组中的值并不相同，我就得到所有不同的值，以及不同的值对应的所有数组元素的索引，举个例子
比如有个int数组，姑且叫int a,如下
[code="java"]int[] a = new int[10][/code]
如果a中的数值都相同，假设都为1，那么我就得到1，同时得到的索引值为0、1、2、3、4、5、6、7、8、9
如果a中的值不相同，比如a的值为{1，1，1，1，1，2，2，3，3，4}，我的到值分别为1、2、3、4。同时，我获得不同的值对应的所有数组元素索引，这个例子中，数值1对应索引0、1、2、3、4，数值2对应索引5、6，数值3对应索引7、8，数值4对应索引9
如果数组的值为{1,1,5,1,2,2,3,5,3,1}，我得到的值为1，5，2，3，数值1对应索引0、1、3、9，数值5对应2、7、数值2对应索引4、5，数值3对应对应索引6、8
要求算法的执行效率要尽可能快，说白了就是运算越快越好。（别告诉我就是两个循环比较--b）
[color=red]附注：如果能用正则表达式获得相同的效果也可以，麻烦您给个完整例子嘿嘿[/color]
小弟就剩7分了，所以只能送5分，想豁出去全送了竟然不行，恳请算法好的朋友写个代码，拜谢，回头去雍和宫给您烧株高香！！！！！
[code="java"]
public static void main(String[] args) {
//核心代码
int[] a = new int[]{1,1,2,1,1,2,2,3,3,4};
Map<Integer,String> map = new HashMap<Integer,String>();
int i = 0;
for(Integer key : a){
if(!map.containsKey(key)){
map.put(key, ""+i);
}else{
map.put(key, map.get(key)+","+i);
}
i++;
}
// 输出结果测试
Iterator ite = map.keySet().iterator();
while(ite.hasNext()){
Integer value = (Integer)ite.next();
String Indexs = map.get(value);
System.out.println(" 值： "+value+" 索引 ："+Indexs);
}
}
[/code]
还有那2分都给我
分我就不用了，留给需要的人吧。
[code="java"]import java.util.*;
public final class Test {
public static Map> partition(int[] array) {
Map> part = new HashMap>();
for (int i = 0; i < array.length; ++i) {
int val = array[i];
if (part.containsKey(val)) {
// seen this value already
part.get(val).add(i);
} else {
// haven't seen this value yet
List indices = new ArrayList();
indices.add(i);
part.put(val, indices);
}
}
return part;
}
public static void main(String[] args) {
int[] a = new int[] { 1, 1, 1, 1, 1, 2, 2, 3, 3, 4 };
Map<Integer, List<Integer>> part = partition(a);
System.out.println("Partition:");
System.out.println(part);
System.out.println();
System.out.println("Values:");
boolean isFirst = true;
for (int v : part.keySet()) {
if (!isFirst) {
System.out.print(", ");
}
System.out.print(v);
isFirst = false;
}
System.out.println();
System.out.println();
System.out.println("Indices:");
for (Map.Entry<Integer, List<Integer>> e : part.entrySet()) {
System.out.printf("%d: %s\n", e.getKey(), e.getValue());
}
}
}
/*
Partition:
{1=[0, 1, 2, 3, 4], 2=[5, 6], 3=[7, 8], 4=[9]}
Values:
1, 2, 3, 4
Indices:
1: [0, 1, 2, 3, 4]
2: [5, 6]
3: [7, 8]
4: [9]
*/[/code]
我写了一段代码
代参考
public static void main(String[] args){
Integer[] c = {1,1,2,1,3,4,1,3,5,5,3};
Set<Integer> set = new HashSet<Integer>();
for(Integer cc:c)
set.add(cc);
Iterator<Integer> it = set.iterator();
while(it.hasNext()){
Integer in = it.next();
System.out.print(in);
System.out.print(":");
for(int i=0;i<c.length;i++){
if(in.equals(c[i]))
System.out.print(i+" ");
}
System.out.println();
}
}
具体要保存到哪,你自己定
楼上那个效率肯定没我这好,每次用map比较去重的,直接用set会自己去重的,所以效率最好
别忘了给分噢,到雍和宫给我烧香呀,哈哈.其实我家就住那附近,兄弟,有事再发贴
[quote="huangnetian"]楼上那个效率肯定没我这好,每次用map比较去重的,直接用set会自己去重的,所以效率最好[/quote]
java.util.HashSet里面就是用java.util.HashMap来实现的，单说Set比Map轻没足够的支持证据。
到底是多用点空间来保存中间数据，只用一次线性遍历就完成数据收集比较好；
还是省点空间，用一次线性遍历之后再接一次双层嵌套循环遍历来完成数据收集比较好，楼上的大大说是后者好。咱就从了大大的吧