int数组有{1，2，1，3，3，2}，如果数组里的值重复，返回true(急求)

Question

int数组有{1，2，1，3，3，2}，如果数组里的值重复，返回true(急求)

Answer 1

这个应该类似于选择排序法吧  只是判断是时候不同而已
  
int [] arr = {1,2,4,5,1,3,4,2};
flag = false;
for(int i=0; i<arr.length(); i++){
    for(int j=i+1; j<arr.length();j++){
        if(arr[i] ==arr[j] ){
            flag = true;
        }
    }
}
return flag;把上面的代码写到一个方法中就行了 

Answer 2

public boolean falg(int array[])
 {
for(int i=0; i<array.length(); i++){
    for(int j=i+1; j<array.length();j++){
        if(array[i] ==arrarrayj] ){
            return true;
        }
    }
}
return false;  }

Answer 3

public class AAA
public boolean falg(int array[])
 {
for(int i=0; i<array.length(); i++){
    for(int j=i+1; j<array.length();j++){
        if(array[i] ==arrarrayj] ){
            return true;
        }
    }
}
return false;  }
public static void main(String args[])
 {
       int [] arr = {1,2,4,5,1,3,4,2};
        System.out.println(new AAA().flag(arr));
 }
}

Answer 4

boolean s=false;
int[] a={1,2,3,5,6};
for(int i=1;i<a.length;i++){
for(int j=0;j<i;j++){
if(a[i]==a[j]){
s=!s;
}
}
}
return s;

Answer 5

前面我的代码里有个错误
  数组没有length()方法  只有length属性

Answer 6

大家给的都是节省空间的算法，还有一种用空间换时间的算法，O(n)=n。不过如果int[]中的元素是负数就不行了。
    public static boolean isRepeat(int[] data){
        int dataLen=data.length;
        boolean[] container;
        int maxVal=0;
        for(int i=0;i<dataLen;i++){   //求目标数组里的最大值
            if(maxVal<data[i]) maxVal=data[i];
        }
        container=new boolean[maxVal+1];//建立一个容器数组，长度为目标数组里的最大值
        for(int j=0;j<dataLen;j++){
            /*容器数组内，第一次碰到，下标为目标数组元素值的元素时，把值改为true*/
            if(container[data[j]]==false) container[data[j]]=true;
            /*当碰到容器数组内，true值时，证明有重复元素*/
            else return true;
        }
        return false;
    }

Answer 7

楼上的方法是不错地，O(n)的时间复杂度。
你可以再扩展下思维，用2n+1的空间。那不就可以处理负数的
清况啦。

Answer 8

import java.util.HashSet;
import java.util.Set;
/**
 * @author jungles
 *
 */
public class UniqueItem { public static boolean judge( Object [] array ) {

if( null == array )
return false;
int size = array.length;
Set<Object>uniqueElement = new HashSet<Object>();
for( int i = 0; i < size; i ++ ) {

uniqueElement.add( array[ i ] );
}
return ( size == uniqueElement.size()?false:true );
}
}
/**
 * @author jungles
 *
 */
public class Main { /**
 * @param args
 */
public static void main(String[] args) {
Integer array[] = {1,2,3,4};
System.out.println( UniqueItem.judge( array ));
}}哈哈，这个的时间复杂度是O(n),空间复杂度也是n的线性函数。对于楼主的情况，需要用Integer替换int。程序在JDK1.6下测试通过。

Answer 9

程序利用了set中元素不能重复的特点解决问题。这是程序中最后一句话：return ( size == uniqueElement.size()?false:true )的蹊跷之处。而且可以判断任何类型的数组元素是否重复，而不仅仅限于int型。

Answer 10

to: SanFire(SanFire)考虑过HashSet的add方法的复杂度嘛?
add方法本身就需要判断元素是否重复.

Answer 11

没办法,估计他连HashSet到底是啥都不知道.

Answer 12

public static void main(String[] args) {
　　int [] arr = {1,2,4,5,1,3,4,2};
　　boolean duplicate = hasDuplicateNumber(arr);
　　System.out.println(duplicate);　　　　
}public static boolean hasDuplicateNumber(int[] nums) {
　　StringBuffer sb = new StringBuffer();
　　for(int num : nums) {
　　　　String s = num + ",";
　　　　if(sb.indexOf(s) < 0) {
　　　　　　sb.append(s);
　　　　}else{
　　　　　　return true;
　　　　}
　　}
　　return false;
}

Answer 13

public boolean falg(int array[])
{
for(int i=0; i<array.length; i++){
for(int j=i+1; j<array.length;j++){
if(array[i] ==arrarrayj] ){
return true;
}
}
}
return false;}

Answer 14

写个省心的public boolean hasRepeat(int[] array) {
return new HashSet(Arrays.asList(array)).size() == array.length;
}

Answer 15

可以行先把数组用堆排序或快速排序进行排序,然后比较相邻的数字,如果有有相同就返回TRUE

Answer 16

有种方法，你把这个数组平分开转换成array类型的，再用collection中有一个方法是用来比较并取出两个数据集中的交集的，获得的数据集如果！＝0，就返回true

Answer 17

换个思路，用set的特性解决重复问题，就简单了，算法也不复杂。

Answer 18

如果不考虑空间问题，那很简单：
public boolean checkDuplication(int[] array) {
  List asList = Arrays.asList(array);
  Set asSet = new HashSet();
  asSet.addAll(asList);
  return asList.size() != asSet.size();
}

Answer 19

public class IfRepeat { /**
 * @param args
 */
public static void main(String[] args) {
int data[] = {2, 3 ,5, 3, 6};
System.out.println((new IfRepeat()).ifRep(data));
} boolean ifRep(int[] arr) {
boolean m = false;
for (int i=0; i<arr.length; i++) {
for (int j= i + 1; j<arr.length; j++) {
if(arr[i]==arr[j]) {
m = true;

} 

}

}
return m;
}
}