算法导论2.3-7题目的解答

请给出一个运行时间为 O(N*lgN)的复杂度，使这能在给定的一个由n个整数构成的集合S和 另一个 整数 sum 时，判断出 S中是否存在 两个和等于 sum 的元素。

先进行合并排序，得到一排序的数组A，时间复杂度为  O(N*lgN) ，

然后，遍历数组中的元素，每次用二分查找 sum-A[i] (注意，二分查收时，查找的目标数组为  A[0,1,2....n-1 ] -A[i] ，除去所在值剩下的数组中查收)

附：二分查找的算法：

首先说说二分查找法。

二分查找法是对一组有序的数字中进行查找，传递相应的数据，进行比较查找到与原数据相同的数据，查找到了返回1，失败返回对应的数组下标。

采用非递归方式完成二分查找法。java代码如下所示。

1.     /* 
2.      * 非递归二分查找算法 
3.      * 参数:整型数组,需要比较的数. 
4.      */  
5.     public static int binarySearch(Integer[]srcArray,int des){  
6.         //第一个位置.  
7.         int low=0;  
8.         //最高位置.数组长度-1,因为下标是从0开始的.  
9.         int high=srcArray.length-1;  
10.         //当low"指针"和high不重复的时候.  
11.         while(low<=high){  
12.             //中间位置计算,low+ 最高位置减去最低位置,右移一位,相当于除2.也可以用(high+low)/2  
13.             int middle=low+((high-low)>>1);  
14.         //与最中间的数字进行判断,是否相等,相等的话就返回对应的数组下标.  
15.         if(des==srcArray[middle]){  
16.             return middle;  
17.         //如果小于的话则移动最高层的"指针"  
18.         }else if(des<srcArray[middle]){  
19.             high=middle-1;  
20.         //移动最低的"指针"   
21.         }else{  
22.             low=middle+1;  
23.             }  
24.         }  
25.         return-1;  
26.         }  
27.       
28. }  

采用递归方式完成二分查找算法。代码如下所示。

1. /** 
2.  * 递归方法实现二分查找法. 
3.  * @param Array数组 
4.  * @param low 数组第一位置 
5.  * @param high 最高 
6.  * @param key 要查找的值. 
7.  * @return 返回值. 
8.  */  
9. int BinSearch(int Array[],int low,int high,int key)  
10. {  
11.     if (low<=high)  
12.     {  
13.         int mid = (low+high)/2;  
14.         if(key == Array[mid])  
15.             return mid;  
16.         else if(key<Array[mid])  
17.             //移动low和high  
18.             return BinSearch(Array,low,mid-1,key);  
19.         else if(key>Array[mid])  
20.             return BinSearch(Array,mid+1,high,key);  
21.     }  
22.     else  
23.         return -1;  

推广：运行时间的复杂度 为 O(N)