黑马程序员技术交流社区

标题: 求解 [打印本页]

---

作者: z47057554    时间: 2015-3-4 17:12
标题: 求解


为什么内存溢出，求解

1. /**
   
2. * 第5题： 数组去重复，
   
3. * 例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
4. * @author
   
5. *
   
6. *答：分析：已知数组，int[]arr,定义起始标记start,定义方法getNewarr(arr,start),该方法可以得到
   
7. *一个数组newarr，newarr在start之后没有元素与arr[start]重复，完动作后，
   
8. *getNewarr(newarr,start++）;当start从0位置开始时，它每调用一次getNewarr，对应位置在新得到的
   
9. *数组中是唯一的，并保留了第一次在原数组中出现的顺序，当start=newarr.length-2时，newarr[start]
   
10. *无论是否等于newarr[newarr.length-1],再调用一次，都会得到所有元素唯一的数组
    
11. */
    
12. 
    
13. public class Test52 {
    
14.         public static void main(String[] args) {
    
15.                
    
16.                 int[] arr={4,2,4,6,1,2,4,7,8};
    
17.                
    
18.                 System.out.println("原数组为");
    
19.                 myPrint(arr);
    
20.                
    
21.                 System.out.println("去重后数组为");
    
22.                 myPrint(getNewarr(arr,0));
    
23.         }
    
24.         
    
25.         public static int[] getNewarr(int[]arr,int start){
    
26.                 if(start < arr.length-1){
    
27.                         int count=0;
    
28.                         for (int i = start+1; i < arr.length; i++) {
    
29.                                 if(arr[i]==arr[start])
    
30.                                         count++;
    
31.                         }
    
32.                         
    
33.                         int[] newarr=new int[arr.length-count];
    
34.                         for (int i = 0; i < start+1; i++) {
    
35.                                 newarr[i]=arr[i];
    
36.                         }
    
37.                         
    
38.                         if(count!=0){
    
39.                                 int arrnum=start+1;
    
40.                                 for (int i = start+1; i < newarr.length; i++) {
    
41.                                         for ( ; arrnum < arr.length; arrnum++) {
    
42.                                                 if(arr[arrnum]==newarr[start])
    
43.                                                         continue;
    
44.                                                 else{
    
45.                                                         newarr[i]=arr[arrnum];
    
46.                                                         arrnum++;
    
47.                                                         break;
    
48.                                                 }
    
49.                                         }
    
50.                                 }
    
51.                                 return getNewarr(newarr,start++);
    
52.                         }
    
53.                         
    
54.                         else
    
55.                                 return getNewarr(arr,start++);
    
56.                 }
    
57.                
    
58.                 else
    
59.                         
    
60.                         return arr;
    
61.         }
    
62.         
    
63.         public static void myPrint(int[] arr){
    
64.                
    
65.                 System.out.print("[");
    
66.                 for(int i=0;i <arr.length;i++){
    
67.                         if(i!=arr.length-1)
    
68.                                 System.out.print(arr[i]+",");
    
69.                         else
    
70.                                 System.out.println(arr[i]+"]");
    
71.                 }
    
72.         }
    
73. }
    
复制代码

---

作者: zfgrinm    时间: 2015-3-4 19:44
你可以考虑用集合，简单易懂

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. /*
   
6. *  8、 数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
7. */
   
8. public class Test8 {
   
9. 
   
10.         public static void main(String[] args) {
    
11.                 // TODO 自动生成的方法存根
    
12.                
    
13.                
    
14.                 int [] arr={4,2,4,6,1,2,4,7,8};
    
15.                
    
16.                 //调用去重方法
    
17.                 Object [] b=getArray(arr);
    
18.                
    
19.                 //打印数组元素
    
20.                 for(int i=0;i<b.length;i++)
    
21.                 {
    
22.                         System.out.println(b[i]);
    
23.                 }
    
24.                
    
25.                
    
26.         }
    
27.         //利用集合中的contains去除重复元素
    
28.         public static Object [] getArray(int []arr)
    
29.         {
    
30.                 //定义集合
    
31.                 ArrayList<Integer> list =new ArrayList<Integer>();
    
32.                
    
33.                 //遍历数组
    
34.                 for(int i=0;i<arr.length;i++)
    
35.                 {
    
36.                         //集合中没有这个元素时，才添加，避免添加重复元素;这里有自动装箱.
    
37.                         if(!list.contains(arr[i]))
    
38.                                 list.add(arr[i]);
    
39.                 }
    
40.                
    
41.                 //集合变数组
    
42.                 return  list.toArray();       
    
43.                
    
44.         }
    
45. 
    
46. }
    

复制代码

---

作者: z47057554    时间: 2015-3-4 19:52

zfgrinm 发表于 2015-3-4 19:44
你可以考虑用集合，简单易懂

看了许久自己发现了，是后置++，先传值，后自增的特点导致的，递归的参数始终是初始值导致的

start++,换成 ++start,就能正确运行了

---

作者: aswq444cs1    时间: 2015-3-5 15:53
加油！自己好好调吧，元宵节快乐！

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2