题目：
一个数组里，除了三个数是唯一出现的，其余的都出现偶数个，找出这三个数中的任一个。比如数组元素为【1, 2,4,5,6,4,2】，只有1,5,6这三个数字是唯一出现的，我们只需要输出1,5,6中的一个就行。

CSDN别人博客看得的
那位先生用的C写的，好吧，我不会C。
感兴趣可以看下。
地址：http://blog.csdn.net/w397090770/article/details/8032898

然后，我想了下用JAVA 写。
思路还算清晰。
几分钟就想出来。
七点半开始写，直到现在才成功。。。三个多小时。。
半个小时写完代码，写完大体，编译报错50多个。。。
当时想哭啊。。{:soso_e109:}
然后修改，不下10次，才算编译过去，
运行结果和预料的不一样，
在修改，又是N次，最后原因是最后的if语句，偷懒没加{}，多谢了:导致的。。。教训
思路是：
1：创建一个新数组，用来记录要选择的数组每个元素出现的次数，
这里借助一个计数器，
特别注意计数器计数完毕需要归零，开始没注意，总是失败。。。
2：然后 选择性输出，出现次数为一次或者多次的元素。
不知道有没有说清楚。。
如图：


代码附上。。。
其他高手有其他算法可以交流。。。{:soso_e181:}

1. <p>
   
2. /*
   
3. 题目：一个数组里，除了三个数是唯一出现的，其余的都出现偶数个，
   
4. 找出这三个数中的任一个。比如数组元素为【1, 2,4,5,6,4,2】，
   
5. 只有1,5,6这三个数字是唯一出现的，
   
6. 我们只需要输出1,5,6中的一个就行。
   
7. 
   
8. */
   
9. 
   
10. class  screen{
    
11.         
    
12.         public void get(int[] arr)
    
13.         {
    
14.                 //定义两个数组用来存储和记录 copy[] 用来复制一遍输入数组 record[] 用来存储数组相同元素出现次数
    
15.                 //counter 用来记录出现次数
    
16.         int counter=0;
    
17.         int record[] = new int[arr.length];
    
18.                 //遍历数组元素
    
19.                 for (int x=0;x<arr.length;x++)
    
20.                 {
    
21.                         for (int y=0;y<arr.length;y++)
    
22.                         {
    
23.                                 if(arr[x]==arr[y])//比较是否相同，本来还有选择性不和自身比较，最后比较懒，没写。。。
    
24.                                 {
    
25.                                         counter++;
    
26.                                 }
    
27.                         }
    
28.                          record[x]=counter;        //用数组记录下元素出现次数
    
29.                          counter=0;//计数器归零，很重要
    
30.                 }
    
31.                 System.out.println();
    
32.                
    
33.                 //找到出现多次的元素
    
34.                 //遍历数组
    
35.                 //查看下定义的数组是否记录准确
    
36.                 //System.out.print("record.lenth="+record.length) ;         
    
37.                
    
38.                 /*for (int x=0;x<arr.length;x++)
    
39.                 {
    
40.                         System.out.print("record ["+x+"]="+record [x]+",");
    
41.                         System.out.println();
    
42.                 }*/
    
43.                 System.out.println();
    
44.                 System.out.print("单次出现的元素是");
    
45.                 for (int x=0;x<arr.length;x++)
    
46.                 {
    
47.                         if(record[x]==1)
    
48.                         {
    
49.                         System.out.print(arr[x]+",");
    
50.                         }
    
51.                 }
    
52.         }
    
53.         
    
54. }        
    
55. 
    
56. 
    
57. public class screenText
    
58. {
    
59.         public static void main(String[] args)
    
60.         {
    
61.                 int arr[]={1, 2,4,5,6,4,2};
    
62.                 screen sc=new screen();
    
63.                 sc.get (arr);
    
64.         }
    
65. }

复制代码

学习了,新手

王龙 发表于 2012-10-27 22:51
学习了,新手

我也新手。。。

对于这种需要数据出现次数的程序，我觉得map集合比较合适
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class ArrTest {
public static void main(String[] args){
    int arr[]={1, 2,4,5,6,4,2};
    ArrOpertation.getSingle(arr);
}
}
class ArrOpertation{
public static void getSingle(int arr[]) {
  TreeMap<Integer, Integer> tm=new TreeMap<Integer, Integer>();
  for(int i=0;i<arr.length; i++){
   if(tm.get(arr[i])==null)
    tm.put(arr[i], 1);
   else
    tm.put(arr[i], tm.get(arr[i])+1);
  }
  StringBuilder sb=new StringBuilder();
  Set<Map.Entry<Integer, Integer>> entrySet=tm.entrySet();
  Iterator<Map.Entry<Integer, Integer>> it=entrySet.iterator();
  while(it.hasNext()){
   Map.Entry<Integer, Integer> me=it.next();
   if(me.getValue()==1)
    sb.append(me.getKey()+",");
  }
  sb.deleteCharAt(sb.length()-1);
  System.out.println("只出现唯一次的数有：（ "+sb.toString()+"）");
  System.out.println(sb.charAt(0)+" 是只出现一次的数字之一！");
}

}

学习了，很好

1. import java.util.*;
   
2. class  Interview
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int[] arr = {1,2,4,5,6,4,2};
   
7.                 print(arr);
   
8.         }
   
9.         public static void print(int[] arr){
   
10. 
    
11.                 List<Integer> list = new ArrayList<Integer>();
    
12. 
    
13.                 for(int i = 0;i<arr.length;i++){
    
14. 
    
15.                         Object num = arr[i];        //num为Object,否则会按角标删除元素
    
16. 
    
17.                         if(list.contains(num)){
    
18. 
    
19.                                 list.remove(num);
    
20. 
    
21.                                 continue;
    
22.                         }else{
    
23. 
    
24.                                 list.add(num);
    
25.                         }
    
26. 
    
27.                 }
    
28. 
    
29.                 System.out.println(list);
    
30.         }
    
31. }

复制代码

1. public class arrCount {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.                 int[] arr = {1,2,4,5,6,4,2};
   
9.                 printarr(arr);
   
10.         }
    
11.         public static void printarr(int[] arr){
    
12.                 Map<Integer,Integer> map = new TreeMap<Integer,Integer>();
    
13.                 int count = 1;
    
14.                 for(int x=0;x<arr.length;x++){
    
15.                         if(map.put(arr[x], count) != null){
    
16.                                 int temp = map.put(arr[x], count);
    
17.                                 map.put(arr[x], temp+1);
    
18.                         }                       
    
19.                 }
    
20.                 Set<Map.Entry<Integer,Integer>> entrySet = map.entrySet();
    
21.                 Iterator<Map.Entry<Integer,Integer>> it = entrySet.iterator();
    
22.                 for(;it.hasNext();){
    
23.                         Map.Entry<Integer, Integer> me = it.next();
    
24.                         int key = me.getKey();
    
25.                         int value = me.getValue();
    
26.                         //System.out.println(key+"="+value);
    
27.                         if(value == 1){
    
28.                                 System.out.print(key+",");
    
29.                         }
    
30.                 }
    
31.         }
    
32. }

复制代码

1. class Zhao
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={1,2,4,5,6,4,2};
   
6.                 for (int x=0;x<arr.length-1 ;x++ )//冒泡排序
   
7.                 {
   
8.                         for (int y=0;y<arr.length-x-1 ;y++ )
   
9.                         {
   
10.                                 if (arr[y]>arr[y+1])
    
11.                                 {
    
12.                                         int b=arr[y];
    
13.                                         arr[y]=arr[y+1];
    
14.                                         arr[y+1]=b;
    
15. 
    
16.                                 }
    
17.                         }
    
18.                 }
    
19.                 for (int x=0;x<arr.length-1 ;x++ )
    
20.                 {
    
21.                         if(arr[x]!=arr[x+1])//找不同...
    
22.                         {
    
23.                                 System.out.println("其中一个为:"+arr[x]);
    
24.                                 break;
    
25.                         }
    
26. 
    
27.                 }
    
28.         }
    
29. }

复制代码

新手一枚 上面的都看不懂- -
之前学过的冒泡排序,感觉可以找找...

徐梦侠 发表于 2012-10-27 23:17
对于这种需要数据出现次数的程序，我觉得map集合比较合适
import java.util.Iterator;
import java.util.Ma ...

map 我还没看到。。。
先make 下。。
:handshake

杨雪松 发表于 2012-10-28 01:16
新手一枚 上面的都看不懂- -
之前学过的冒泡排序,感觉可以找找...

因为题目要求找出一个就行
如果都列出来应该是arr[x-1]!=arr[x]&&arr[x]!=arr[x+1]
也就不用break了;
so

可以先实现排序，然后比较一个数字的前后数字是否相等，这样是否会好点！？

黑马吕世成 发表于 2012-10-28 20:57
可以先实现排序，然后比较一个数字的前后数字是否相等，这样是否会好点！？ ...

恩,可以的.
我这样写,为了考虑如果筛选出现其他次数的情况,修改计数器就O了。。
面试题而已，都可以，，呵呵