数组消除重复元素的简单问题

Question

在帖中看到了一个这样的问题．如int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5},消除其中的重复元素．
我是这样想的．再利用一个Destination数组，先把Source中的第一个元素1给Ｄｅｓｔｉｎａｔｉｏｎ，然后判断第二个元素跟Destination中的前面元素是不是相等，相等的话，i加1，然后用同样的方法．代码如下：但是可能存在一些错误．请帮我找出，我怎么也找不出来了．声明，就用我说的这种方法，其他方法不用．
class Test
{
public static void main(String[] args)
{
      int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5};
      int[] Destination=new int[20];
      Destination[0]=Source[0];
      int i=1,j=1;
        while(i<15)
      {
       int k;
       for(k=0;k<j;k++)
       {
       if(Source[i]==Destination[k])
       {
       i++;
       k=-1;
         }
       }
       Destination[j]=Source[i];
        i++;
        j++;
      }
      for(int m=0;m<Destination.length;m++)
      System.out.println(Destination[m]);
}
}

Answer 1

这是你说的方法，仅供参考，共同学习:)class Test 
{ 
public static void main(String[] args) 
{ 
      int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5}; 
      int[] Destination=new int[20]; 
      Destination[0]=Source[0]; 
      int i=1,j=1,k=0; 
      while(i <15) 
      { 
        if (Source[i]==Destination[k])
         i++;
        else{
          Destination[j]=Source[i]; 
          k=j;
          i++; 
          j++; 
        }
      } 
      for(int m=0;m <j;m++) 
      System.out.println(Destination[m]); 
} 
}

Answer 2

个人觉得 while (i<15)改成 (i < Source.length)更好。
输出的for循环，我将Destination.length改成了j，是为了避免输出若干个0.

Answer 3

再说说你的程序的错误吧，在下面这个循环语句里，显然k的值会永远=0，也就说，这个for(k=0; k<j; k++)实际上是个无限循环。
在这个情况下，i的值会不停的增加。当它增加到15的时候，Source[15]已经下标越界了，所以。      for(k=0;k <j;k++)        <-- 无限循环
      { 
      if(Source[i]==Destination[k]) 
      { 
      i++; 
      k=-1; 
        } 
      } 

Answer 4

这个命题有问题的，当一个数组被声明出来就不能改变其大小了。int[] Destination=new int[20];这个数组就不等了。会出现数组越界。

Answer 5

Destination数组比Source大，而比较&拷贝是以Source的大小为准，所以不会出现越界问题吧。
只是这样的设计不太合理。

Answer 6

能把数组里的数据放到其它工具里面吗？
放到 map完成。。呵呵

Answer 7

用你的方法，输出的数组中有很多的0；因为你不知道原来的数组中有多少的没重复的数。你又声明的一个数组的长度就不能确定了，最好用容器。下面是安你的方法来的。输出的又很多的0；class TT {  public static void main(String[] args) 
{ 
      int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5}; 
      int[] Destination=new int[Source.length];
      
      for(int i=0;i<Source.length-1;i++) {
       if(Source[i]<Source[i+1]) {
       Destination[i]=Source[i];
       //System.out.println(Destination[i]);
       }
    
      }
      Destination[Destination.length-1]=Source[Source.length-1];
      
      for(int i=0;i<Destination.length;i++) {
       System.out.println(Destination[i]);
      }
      
}
}

Answer 8

用容器做了个。import java.util.ArrayList;
import java.util.List;class TT {  public static void main(String[] args) 
{ 
      int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5};       List<Integer> L=new ArrayList<Integer>();
      for(int i=0;i<Source.length-1;i++) {
       if(Source[i]<Source[i+1]) {
       L.add(Source[i]);
       }
    
      }
      L.add(Source[Source.length-1]);
      
      for(int i=0;i<L.size();i++) {       
       System.out.println(L.get(i));
      }
      
}
}

Answer 9

public class  Test {
public static void main(String[] args) {
       int[] Source={1,2,2,3,3,3,4,4,4,4,5,5,5,5,5};
       int[] Destination = new int[20];
       Destination[0]=Source[0]; 
int i = 1, j = 0;
   while(i<Source.length){
   if(Source[i]==Destination[j]){
   i++;
   }else{
 j++;
 Destination[j] = Source[i];
 i++;
   }
   }

   for(int m = 0; m<j+1;m++){
   System.out.print(Destination[m]+" ");
   }
}
}

Answer 10

if(Source[i]==Destination[k])，造成了数组下标越界
这个for(k=0; k <j; k++)实际上是个无限循环

Answer 11

public static void main(String[] args)
{
      int[] Source = {1,2,2,3,3,3,4,4,4,4,5,5,5,5,5};
      int[] Destination = new int[20];
      Destination[0]=Source[0];
      int i = 0, k = 0, j = 1;
      boolean flag;
      while(i < Source.length)
      {
       flag = true;
       for(k = 0; k < j && i < Source.length; k ++)
       {
       if(Source[i]== Destination[k])
       { 
       flag = false;
       i ++ ;
       break;
       }
       } 
       if(flag){
       Destination[j] = Source[i];
       i++;
       j++;
       }
      }
      for(int m=0;m <Destination.length;m++)
      System.out.print(Destination[m] + ";");
}

Answer 12

该方法是不行的，实际打乱下顺序就不可以了
比如Source={1,2,3,2,3,3,4,4,4,4,5,5,5,5,5}

Answer 13

就像上楼所说的，二楼的方法具有局限性，我这个有争议的for循环是为了当在当前的源数组元素已经存在在目的数组中时候，不仅能够迅速查找下一个元素是否存在于目的数组，而且通过k=-1操作，使下一个元素还可以与目的数组元素的第一个元素比较，到j的位置比较结束！！等待正确答案，这个数组不一定是我所说的这种样式，只要有重复元素，不管怎样排列都是可以消除的．

Answer 14

九楼的方法太局限了，也许你的算法只能适合所给的这样类型的数组：下面给一个应用广的．
import java.util.*;
public class D
{ public static void main(String[] args) 
{
List l=new ArrayList();
int[] Source={1,2,2,3,3,66,6,6,4,4,4,4,5,5,5,5,5};
for(int i=0;i<Source.length;i++)
{
if(!l.contains(Source[i]))
l.add(Source[i]);
}

for(int i=0;i<l.size();i++)
{
System.out.println(l.get(i));
}

}}