找出被替换的整数

问题描述：

    给定一个大小为100的整形数组，存放1->100之间的所有100个整数（无序），用一个>100的整数替换数组中的任何一个数，要求找出被替换的数

    1，直接想到的办法就是依次数组中的哪个数不在数组之中，该方法时间复杂度为O(n*n),空间复杂度为O(n)

    2，使用排序方法先将数组进行排序，然后在查找哪个数据不在数组之中，使用快速排序算法时间复杂度为O(nlgn),空间复杂度为O(n)

    3，使用map映射，将数组中的数据存放到map中，然后依次判断1->100中的每一个数是否存在

    4，1->100所有数的和为定值5050，找出替换的那个数replaceInt，用5050-replaceInt即可得到剩余99个数的和，然后用数组中所有数的和Sum-(5050-replaceInt)即为所<span style="white-space:pre">	</span>要求的数。

下述代码中省去快速排序方法，保留其余三种方法。

package com.fupeng.csdn;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/*
 * 找出数组中被替换的数
 * 问题描述：给定1->100的整数，存放到一个长度为100的数组中，用1-100以外的数将其替换，要求找出被替换的数
 * 方法一：最简单直接的想法就是，依次从（1--100）遍历数组，查找哪个数不在数组中
 * 方法二：使用map映射，将被打乱的数组值存放到对应大小的map中，然后依次判断（1--100）每个数是否在map中
 * 方法三：1，1--100所有数的和为一个定值5050，被替换之后的数组的和为sum，
 * 				2，首先找出被替换的数replaceInt，用sum-replaceInt即得出数组中不包括被替换数的和
 * 				3，使用5050-（sum-replaceInt）即为要查找的数
 * 程序描述：只需要改变数组的大小，即可实现1----N中查找
 */
public class FindNumBeReplace {

	public static void main(String[] args) {
		Random random=new Random();
		int[] array=new int[5];
		//数组顺序存放1--100
		for(int i=0;i<array.length;i++){
			array[i]=i+1;
		}
		//打乱数组数字的次序
		int temp=0;
		for(int i=0;i<array.length;i++){
			int index=random.nextInt(array.length);
			if(index!=i){
				temp=array[i];
				array[i]=array[index];
				array[index]=temp;
			}
		}
		//产生一个101-1000之间的随机数，随机替换其中一个数
		int index=random.nextInt(array.length);
		int value=random.nextInt(900)+101;
		array[index]=value;
		printArray(array);
		System.out.println("方法一"+"\n"+"被替换的数是："+findBeRepleace1(array));
		System.out.println("方法二"+"\n"+"被替换的数是："+findBeRepleace2(array));
		System.out.println("方法二"+"\n"+"被替换的数是："+findBeRepleace3(array));
	}
	
	/*
	 * 方法一的实现
	 * @param int[] array为长度为100的数组，并且其中存放的是99个1--100的数和一个其他的数
	 * @param return 返回值为被替换的值
	 * 该方法的时间复杂度为o(n*n)空间复杂度为O(n)
	 */
	public static int findBeRepleace1(int[] array){
		int result=0;
		for(int i=1;i<=array.length;i++){
			int j=0;
			while(j<array.length&&i!=array[j])
				j++;
			if(j==array.length)
				result=i;
			}
		return result;
		}
	
	/*
	 * 方法二的实现
	 * 时间复杂度为O(n)，空间复杂度为O(2n)
	 * @param int[] array数组为目标数组，
	 * @param return 为所需要查找的数
	 */
	public static int findBeRepleace2(int[] array){
		int result=0;
		Map<Integer, Integer>map=new HashMap<Integer, Integer>();
		//将数组值存放到map中，时间复杂度为O(n)，空间复杂度为O(2n)
		for(int i=0;i<array.length;i++){
			map.put(array[i], 0);
		}
		//依次从1--100在查找map，找出不存在map中的数
		for(int i=1;i<=array.length;i++){
			if(!map.containsKey(i))
				result=i;
		}
		return result;
	}
	
	/*
	 * 方法三的实现
	 * @param int[] array数组为目标数组，
	 * @param return 为所需要查找的数
	 * 时间复杂度为O(n),空间复杂度为O(n)
	 */
	public static int findBeRepleace3(int[] array){
		//定义原数组的和
		int OldArraySum=0;
		//定义新数组的和
		int newArraySum=0;
		//首先遍历数组，找出替换的数replaceInt
		int replaceInt=0;
		int i=0;
		while(i<array.length&&replaceInt<=array.length){
			if(array[i]>array.length)
				replaceInt=array[i];
			i++;
		}
		//对array数组求和,对原数组求和,原数组是从1--array.length的数
		for(int j=1;j<=array.length;j++){
			newArraySum+=array[j-1];
			OldArraySum+=j;
		}
		//被替换的数值为OldArraySum-(newArraySum-replaceInt)
		return OldArraySum-(newArraySum-replaceInt);
	}
	
	
	/*
	 * 打印数组
	 */
	public static void printArray(int[] array){
		for(int i=0;i<array.length;i++){
			System.out.print(array[i]+"　");
		}
		System.out.println();
	}
}

为了便于调试，选择1->5 5个整数来进行测试，测试结果为：

5　2　4　223　3　
方法一
被替换的数是：1
方法二
被替换的数是：1
方法二
被替换的数是：1