Java算法分析1—————寻找数组同样元素

算法的两个评測指标：执行时间和内存消耗

要么用时间换空间，要么用空间换时间

寻找数组同样元素測试一：

0~99共100个元素各不同样，新增加一个0~99的元素不明白位置

从101个元素数组中找出与0~99元素中反复的一个

/* 找同样元素
 * 0~99共100个元素各不同样
 * 从101个元素数组中找出与0~99元素中反复的一个
 */
public class Dome01 {
	public static void main(String[] args) {
		int arr[] = new int[101];
		for (int i = 0; i < 100; i++) {
			arr[i] = i;
		}
		arr[100] = 38; // 假定反复元素为38
		// 将数组元素打乱 Math.random() 取值范围是[0,1)

		// 怎样打乱数据?

?

for (int j = 0; j < 1000; j++) { // 进行1000次数据打乱的操作
			int num1 = (int) (Math.random() * 101); // num取值范围是[0,101)
			int num2 = (int) (Math.random() * 101);
			int temp = arr[num1];
			arr[num1] = arr[num2];
			arr[num2] = temp;
		}

		// 算法一：用双循环实现
		Jonney: for (int i = 0; i < arr.length; i++) {
			// 将数组元素依次与后面的数组元素比較
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] == arr[j]) {
					System.out.println("反复元素是:" + arr[i]);
					break Jonney; // 退出双循环
				}
			}
		}
		// 算法一效率太低

		// 算法二：将数组的元素所有累加起来就是0~99的数据+同样元素 再减去0~99的和
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		for (int j = 0; j < 100; j++) {
			sum -= j;
		}
		System.out.println("反复元素是:" + sum);
		// 算法二假设计算的数据太多就会有数据溢出

		// 算法三：使用异或解决
		// 0^1^2^3^4^...^m...^99^m^0^1^2^3^4^...^m...^99=m
		// 使用数组的第一个元素异或后面的所有元素
		for (int i = 1; i < arr.length; i++) {
			arr[0] = arr[0] ^ arr[i];
		}
		// 再次将arr[0]保存的结果与0~99异或一次
		for (int i = 0; i < 100; i++) {
			arr[0] = arr[0] ^ i;
		}
		System.out.println("反复元素是:" + arr[0]);
		// 算法三才是最佳算法
	}
}

寻找数组同样元素測试二：

0~99共100个整数，各不同样，将全部数放入一个数组，随机排布

数组长度100，将当中随意一个数替换成0~99还有一个数(唯一反复的数字)

将反复的数字找出

/*
 * 0~99共100个整数，各不同样，将全部数放入一个数组，随机排布
 * 数组长度100，将当中随意一个数替换成0~99还有一个数(唯一反复的数字)
 * 将反复的数字找出
 */
public class Dome2 {

	public static void main(String[] args) {
		int arr[] = new int[100];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		// 随机排布
		for (int i = 0; i < 1000; i++) {
			int num1 = (int) (Math.random() * 100);
			int num2 = (int) (Math.random() * 100);
			int temp = arr[num1];
			arr[num1] = arr[num2];
			arr[num2] = temp;
		}
		// 用某个值给某个值替换
		int num1 = (int) (Math.random() * 100);
		int num2 = (int) (Math.random() * 100);
		// 保证num1与num2不同
		while (num1 == num2) {
			num1 = (int) (Math.random() * 100);
		}
		System.out.println("将" + num1 + "位置的值用" + num2 + "的位置替换");
		arr[num1] = arr[num2];
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}

		// 算法实现：
		// 算法一：用双循环实现
		Jonney: for (int i = 0; i < arr.length; i++) {
			// 将数组元素依次与后面的数组元素比較
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] == arr[j]) {
					System.out.println("反复元素是:" + arr[i]);
					break Jonney; // 退出双循环
				}
			}
		}
		// 算法一效率太低

		// 算法二：用数组优化的算法
		// 定义一个新数组 int newArr[]=new int[100] 默认值为0
		// 把原始数组的元素作为新数组的下标，假设该下标相应的新数组元素存在，就将该元素值+1=1
		/*
		 * 原始数组         8 3 7 2 1 5 6 8 0
		 * 新数组           0 0 0 0 0 0 0 0 0
		 * 对新数组+1       1 1 1 1 0 1 1 1 2
		 */
		// 新数组中元素为2的值的下标就是反复元素
		int newArr[] = new int[100];
		for (int i = 0; i < arr.length; i++) {
			newArr[arr[i]]++; // 将原始元素对于新数组的索引下标
			if (newArr[arr[i]] == 2) {
				System.out.println("反复元素是:" + arr[i]);
			}
		}

	}

}

PS：測试二中的新定义个新数组的数组优化算法，尽管加快了查询速度。但也加大了内存开销