int数组有{1，2，1，3，3，2}，如果数组里的值重复，返回true(急求)
int数组有{1，2，1，3，3，2}，如果数组里的值重复，返回true(急求)
[解决办法]
这个应该类似于选择排序法吧 只是判断是时候不同而已
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;
把上面的代码写到一个方法中就行了
[解决办法]
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;
}
[解决办法]
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;
[解决办法]
貌似有个效率的．
[解决办法]
这个问题，确实有效率。
[解决办法]
大家给的都是节省空间的算法，还有一种用空间换时间的算法，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;
}
[解决办法]
楼上的方法是不错地，O(n)的时间复杂度。
你可以再扩展下思维，用2n+1的空间。那不就可以处理负数的
清况啦。
[解决办法]
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下测试通过。
[解决办法]
同上
[解决办法]
to: SanFire(SanFire)
考虑过HashSet的add方法的复杂度嘛?
add方法本身就需要判断元素是否重复.
[解决办法]
学习下~~~~~~~~
[解决办法]
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;
}
[解决办法]
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 boolean hasRepeat(int[] array) {
return new HashSet(Arrays.asList(array)).size() == array.length;
}
[解决办法]
可以行先把数组用堆排序或快速排序进行排序,然后比较相邻的数字,如果有有相同就返回TRUE
[解决办法]
有种方法，你把这个数组平分开转换成array类型的，再用collection中有一个方法是用来比较并取出两个数据集中的交集的，获得的数据集如果！＝0，就返回true
[解决办法]
换个思路，用set的特性解决重复问题，就简单了，算法也不复杂。
[解决办法]
用堆栈或者二叉树来做如何？
[解决办法]
如果不考虑空间问题，那很简单：
public boolean checkDuplication(int[] array) {
List asList = Arrays.asList(array);
Set asSet = new HashSet();
asSet.addAll(asList);
return asList.size() != asSet.size();
}
[解决办法]
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;
}
}
