寻找数组中的重复数字（java，可执行程序）

package Array;

import java.util.ArrayList;
import java.util.Arrays;

public class ex3_2 {
	public static void main(String[] args) {
	class Duplication {
//************************************①找到一个重复的数字，低时间复杂度，借助辅助数组********************************//
//		int FindOneRepNumT(int[] a) {
//			int n=a.length;			
//			for (int i=0;i<n;i++) {
//				if ((a[i]<1)||(a[i]>n-1))
//					return -1;//数组元素不合法
//			}
//			if(n<=0)
//				return -3;//数组长度不合法
//			int result=0;		
//			int[] temp=new int[n];		
//			for(int i=0;i<n;i++) {
//				if(temp[a[i]-1]==0) {
//				System.out.println(Arrays.toString(temp));				
//				temp[a[i]-1]=a[i];	
//				}
//				else {
//				result=a[i];	
//				System.out.println(result);
//				return result;				
//				}
//			}			
//			return -2;//没有重复元素	
//		}
//************************************②找到所有重复的数字，低时间复杂度，借助辅助数组********************************//	
//		ArrayList FindAllRepNumT(int[] a) {
//			int n=a.length;
//			int[] temp=new int[n];
//			ArrayList none=new ArrayList<>();
//			ArrayList all=new ArrayList<>();
//			for (int i=0;i<n;i++) {
//			if ((a[i]<1)||(a[i]>n-1)) {
//				ArrayList En=new ArrayList<>();	
//				En.add(-1);
//				return En;//数组元素不合法
//				}
//			}
//			if(n<=0) {
//				ArrayList Le=new ArrayList<>();	
//				Le.add(-2);
//				return Le;//数组元素不合法				
//			}
//			for(int i=0;i<n;i++) {
//				if(temp[a[i]-1]==0) {
//					temp[a[i]-1]=a[i];
//				}
//				else {
//					all.add(a[i]);
//				}
//			}
//			return all;	
//		}		
//************************************③找到任一重复数字，低空间复杂度，类似二分********************************//	
		int CountNum(int[] a,int start,int end) {//计算数组a中[start,end]闭区间的元素个数
			int n=a.length;
			int count=0;
			for (int i=0;i<n;i++) {
				if((a[i]<=end)&&(a[i]>=start))
					count++;
			}
			return count;
		}
		
		int FindOneReapNumS(int[] a) {
			int n=a.length;
			int start=1;
			int end=n-1;
			if(n<=0)
				return -2;
			for (int i=0;i<n;i++) {
				if ((a[i]<1)||(a[i]>n-1))
					return -1;
			}
			while(start<=end) {
				int m=(end-start)/2+start;
				int count1=CountNum(a,start,m);
				if (end==start) {
					if(count1>1)
						return end;
					else
						break;
				}
				if(count1>(m-start+1)) 
					end=m;
				else {
					start=m+1;
				}
			}
			return -3;
		}
		
//************************************④找到所有重复数字，低空间复杂度********************************//				
		int FindAllReapNumS(int[] a) {
			//待补充

			
			return 0;
			
		}
	}	
	Duplication d=new Duplication();
	int[]a= {1,2,2,3,3,4};
//************************************测试********************************//	
//	int fOT=d.FindOneRepNumT(a);	
//	switch(fOT) {
//	case -1:
//		System.out.println("One时间复杂度比较低的算法测试结果：数组元素不合法");
//		break;
//	case -2:
//		System.out.println("One时间复杂度比较低的算法测试结果：数组长度不合法");
//		break;
//	case -3:
//		System.out.println("One时间复杂度比较低的算法测试结果：没有重复元素");
//		break;
//	default:
//	System.out.println("One时间复杂度比较低的算法测试结果：重复的数字是"+fOT);
//	}
//************************************测试********************************//		
//	ArrayList fAT=new ArrayList<>();
//	fAT=d.FindAllRepNumT(a);
//	int fATSize=fAT.size();
//	fAT.trimToSize();
//	Integer[] result=new Integer[fAT.size()];
//	fAT.toArray(result);
//	int flag;
//	if(result[0]==-1)
//		flag=-1;
//	else if(result[0]==-2)
//		flag=-2;
//	else if(fATSize==0)
//		flag=-3;
//	else flag=-4;
//	switch(flag) {
//	case -1:
//		System.out.println("All时间复杂度比较低的算法测试结果：数组元素不合法");
//		break;
//	case -2:
//		System.out.println("All时间复杂度比较低的算法测试结果：数组长度不合法");
//		break;
//	case -3:
//		System.out.println("All时间复杂度比较低的算法测试结果：没有重复元素");
//		break;
//	default:
//		System.out.println("All时间复杂度比较低的算法测试结果：重复的数字是"+Arrays.toString(result));
//	}
//************************************测试********************************//		
	int fOS=d.FindOneReapNumS(a);
	switch(fOS) {
	case -1:
		System.out.println("One空间复杂度比较低的算法测试结果：数组元素不合法");
		break;
	case -2:
		System.out.println("One空间复杂度比较低的算法测试结果：数组长度不合法");
		break;
	case -3:
		System.out.println("One空间复杂度比较低的算法测试结果：没有重复元素");
		break;
	default:
	System.out.println("One空间复杂度比较低的算法测试结果：重复的数字是"+fOS);
	}
	
	}
}