编程珠玑之第二章

1. 问题1

问题描述: 给定一个最多包含40亿个随机排列的32位整数的顺序文件,找出一个不在文件中的32位整数(在文件中至少缺失一个这样的数,为什么?).

(1)在具有足够内存的情况下, 如何解决该问题?

(2)如果有几个外部的"临时"文件可用,但是仅有几百字节的内存, 又该如何解决该问题?

问题思路: 由于2^32 = 4 294 967 296，超过给出的40亿,因此必定存在32位的整数不在此文件中.

(1) 当内存足够的情况下,使用位图法来寻找不在文件中的整数, 即位表示中,出现次数为0的整数.

此时需要的内存空间:(2^32)/8 = 最大数/一个字节可以表示8位 = 2^29B = 2^9MB = 512MB.

(2) 内存不够时,但可以使用外部临时文件, 使用二分查找.

       由于存储数据都是32位的, 可以根据32位中的某一位将原始数据分为两部分. 例如从最高位开始,统计最高位为1的数据个数,即大于等于2^31的元素,并将其存储在一个文件中;同时也统计最高位为0的数据个数,即小于2^31的数,并将其存储在另外一个文件中;

        接着比较最高位为1和最高位为0的个数大小, 若这两部分数的个数一样, 说明两边缺失数据个数是一样的, 由于只用找出一个缺失的个数,故随机选择一边进行下一步操作既可;

       若这两部分数据个数不一样, 说明个数少的缺失的数据个数肯定比个数多的那部分要多, 一个缺一个不缺或两个都缺, 此时肯定选择个数小的那部分进行下一步操作.

      最后,处理第二高位,递归进行,直到所有位都遍历结束,就可以找到缺失的值.

下面是java实现的代码,实际操作时应该从文件中读取数据,并将数据写入文件中:

<span style="font-size:14px;">package test;
/*
 * 从随机排列的文件中,找出不在文件中的整数
 * 重要思想是二分搜索
 */
public class FindLostNumber {
	public static void main(String[] args){
		int bits = 4; //数据是4位,用位操作比较简单,可以很简单明确的将数据分为大小一样的两部<span style="font-family:Arial;">分</span>
		
		int[]  arr = {0,1,2,3,4,5,6,7,9,10,11,13,14,15};
		
		int lostNumber = findLostNumber(arr,bits);
		System.out.print("the lost number is :"+lostNumber);
	}
	
	public static int findLostNumber(int[] arr,int bits){
		int num0 = 0, num1 = 0; //分别统计当前位是0和1的数的数目
		int len = arr.length;
		int[] arr0 = new int[len];
		int[] arr1 = new int[len];
		int lostNumber = 0;
		for(int i = bits-1;i>=0;i--){
			int flag = 1 << i;
			num0=0;
			num1=0;
			for(int j=0;j<len;j++){
				if((flag & arr[j]) == 0)
					arr0[num0++] = arr[j];
				else
					arr1[num1++]=arr[j];
			}
			if(num0 < num1){
				arr = arr0;
				len = num0;
			}else{//代表缺失的数在当前位是1的这边,故缺失值的当前位为1
				arr = arr1;
				len = num1;
				lostNumber += flag;
			}
		}
		return lostNumber;
	}
}
</span>

2. 问题2

问题描述: 将一个n元一维向量向左旋转i个位置, 例如,当n=8且i=3时,向量abcdefgh旋转为defghabc.简单的代码使用一个n元的中间向量在n步内完成该工作.能否仅使用数十个额外字节的存储空间,在正比于n的时间内完成向量的旋转?

问题求解:

解决方案1: 将ab转换成ba, 首先对a求逆,得到a'b,然后只对b求逆,得到a'b',最后再对整体求逆,得到(a'b')',此时结果就是ba.即先局部翻转,然后再整体翻转.

相同解法的一个问题:输入一个英文句子,翻转句子中单词的顺序,但是单词内字符的顺序不变.

解法就是,首先将每个单词单独翻转,然后再整个句子翻转即可.

伪代码如下:

reverse(0,i-1); //cbadefgh

reverse(i,n-1)；//cbahgfed

reverse(0,n-1)；//defghabc

java实现代码如下:

<span style="font-size:14px;">package test;
/*
 * 将一个n元向量向左移动i个位置
 */
public class Reverse {

	//实现在数组中从low到high元素的整体翻转
	public static void reverse(char[] arr,int low,int high){
		char temp;
		for(int i= 0;i<=(high-low)/2 ;i++){
			temp=arr[low+i];
			arr[low+i] = arr[high-i];
			arr[high-i] = temp;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			String str = "abcdefgh";
			int len= str.length();
			int i =3;
			char[] arr = str.toCharArray();
			
			reverse(arr,0,i-1);
			reverse(arr,i,len-1);
			reverse(arr,0,len-1);
			
			String str1="";
			for(int j=0;j<len;j++)
					str1+=arr[j];
			System.out.print(str1);
	}

}
</span>

解决方案2: 杂耍算法

思路: 对数组中的每一个元素向左移动i位,超过数组长度的可以取模回到数组中,最终就会得到结果.

步骤:(i表示循环移动的位数)

(1)先将x[0](即第一个存储的元素)保存在临时变量temp中;

(2)将x[i]移动到x[0]中,x[2i]移动到x[i]中,依次类推

(3)将x中的所有下标都对x.length取模,直到再次需要从x[0]中提取元素.然后此时从temp中提取元素,结束.

循环的终止条件: 当从循环的起始位置点提取元素时,此时循环终止.

注意: 当n和i互质时, 只需要一次循环就可以处理完所有元素; 当n与i不互质时,将原始数据分为一块块,每块大小为i,每次处理各个块的相同位置的元素.

java实现代码如下:

<span style="font-size:14px;">//求2个数的最大公约数i<n
	public static int gcd(int n, int i){
		if(n<i){//确认n大于i
			int temp=i;
			i=n;
			n=temp;
		}
		
		if(n%i==0)
			return i;
		else{
			return gcd(i,n%i);
		}
	}
	
	//杂耍算法
	public static void rotate(char[] arr, int i, int len){
		int iter = gcd(len,i);
		for(int j=0;j<iter;j++){
			int firstNum = j;
			int next = firstNum + i;
			char temp = arr[firstNum];
			while(next != j){
				arr[firstNum] = arr[next];
				firstNum = next;
				next = (next + i)%len;
			}
			arr[firstNum] = temp;
		}
	}</span>

解决方案3: 块交换.

旋转向量其实就是交换向量ab,得到向量ba.a代表x的前i个元素.若a比b短, 则将b分成b1b2,且使得b2的长度和a一样,交换a和b2,得到b2b1a,则序列a此时处于最终位置,此时旋转向量的目标变为旋转b2b1;若a比b长,则将a分为a1a2,其中a1的长度和b的长度一样,交换a1和b,得到ba2a1,此时序列b到达最终位置,则原来的旋转向量目标变为旋转a2a1.递归上述过程,直到a和b的长度相等时,此时之需要交换a和b这两个序列即可.

java实现代码如下:

<span style="font-size:14px;">//采用块变换来实现左旋转,依次为数组,旋转开始位置,涉及旋转字符串长度,,旋转位数
	public static void rotate3(char[] arr, int start, int len, int bits){
		
		
		int leftstart = start;
		int rightstart = start + bits;
		
		int leftlen = bits;
		int rightlen = len-bits;
		
		if(leftlen < rightlen){
			swap(arr,leftstart,leftstart+len-bits,bits);
			rotate3(arr,leftstart,len-bits,leftlen);
		}else if(leftlen > rightlen){
			swap(arr,leftstart,rightstart,rightlen);
			rotate3(arr,leftstart+rightlen,len-rightlen,leftlen-rightlen);
		}else{
			swap(arr,leftstart,rightstart,rightlen);
		}
	}
	
	
	public static void swap(char[] arr, int l1, int r1,int len){
		char temp;
		for(int i =0;i<len;i++){
			temp = arr[l1+i];
			arr[l1+i] = arr[r1+i];
			arr[r1+i] = temp;
		}
	}</span>

3. 问题3

问题描述: 给定一个英语字典,找出其中所有的变位词集合.例如,'pots'/'stop'/'tops'互为变位词,因为没一个单词都可以通过改变其它单词中字母顺序得到.

问题求解: 原始问题可以转换为2个子问题:选择标识和集中具有相同标识的单词.

(1)为每一个单词生成一个标签, 且其所有的变位词都得有一样的标签: 一种方法: 把每个单词所包含的字母按照字母顺序排序, 在此基础上改进的方法是字母+出现次数,例如mississippi可以转换为i4m1p2s4,可以将出现一次的1省略.第二种方法: 使用一个包含26个整数的数组来标识每个字母出现的次数.

(2)根据标签收集单词,每个标签对应一个集合,这个集合包含其所有的变位词.可以使用hashmap来存储,键为标签,值为set,存储所有的变位词.

参考:

http://blog.csdn.net/insistgogo/article/details/7749328