第三周作业 --------顺序查找和二分查找

1. 2. 查找。Bentley在他的著作《Writing Correct Programs》中写道，90%的计算机专家不能在2小时内写出完全正确的二分搜索算法。
       二分查找方法原型：int BSearch(int array[], int low, int high, int target )， array——含有若干整数的数组，low 与 high——查找的起始、结束下标，target——待查找的元素。
       顺序查找：int SSearch(int array[], int low, int high, int target )，其中S——Sequence（顺序）
       数组array中数据来自于第1题中的排序结果文件largeW_bubble.txt，待查找数据来自于文件 tinyW.txt（ 下载链接）。请在控制台输出不在largeW_bubble.txt的数据。
   
   
2. 
   
3. 
   
4. 
   
5. package com.suanfa;  
6.   
7. import java.io.BufferedReader;  
8. import java.io.File;  
9. import java.io.FileInputStream;  
10. import java.io.InputStreamReader;  
11. import java.util.ArrayList;  
12. import java.util.List;  
13.   
14. public class mychaz {  
15.   
16.     /**顺序查找和二分查找 
17.      * @param args 
18.      */  
19.     public static void main(String[] args) {  
20.          String pathBubble="src/largeW_bubble.txt";  
21.          String pathTinyW="src/tinyW.txt";  
22.          try{  
23.              File fileBubble=new File(pathBubble);  
24.              InputStreamReader reader=new InputStreamReader(new FileInputStream(fileBubble));  
25.              BufferedReader buffereader=new BufferedReader(reader);  
26.              List<String> list=new ArrayList<String>();  
27.              String num="";  
28.              //读取largeW_bubble.txt已排序好的文本数据存放到数组中  
29.              while((num=buffereader.readLine())!=null){  
30.                  list.add(num.trim());  
31.              }  
32.              int array[]=new int[list.size()];  
33.              for(int i=0;i<array.length;i++){  
34.                  array[i]=Integer.parseInt(list.get(i));  
35.              }  
36.                
37.              //读取tinyW.txt的数据并且在largeW_bubble.txt已排序好数组中查找  
38.              File fileTinyW=new File(pathTinyW);  
39.              buffereader=new BufferedReader(new InputStreamReader(new FileInputStream(fileTinyW)));  
40.              while((num=buffereader.readLine())!=null){  
41.                  //非递归的方式二分查找  
42.                  int location = binarySearch(array,0,array.length-1,Integer.parseInt(num.trim()));  
43.                  if(location!=-1){  
44.                      //System.out.println("二分查找中tinyW.txt的数据在largeW_bubble.txt中位置是："+location+" 所对应的数据是："+array[location]);  
45.                  }else {  
46.                      System.out.println("二分查找中找不到 所对应的数据："+num);  
47.                  }  
48.                  //顺序查找  
49.                  location=SSearch(array,0,array.length-1,Integer.parseInt(num.trim()));  
50.                  if(location!=-1){  
51.                     System.out.println("顺序查找中tinyW.txt的数据在largeW_bubble.txt中位置是："+location+" 所对应的数据是："+array[location]);  
52.                  }else{  
53.                      System.out.println("顺序查找中找不到 的数据是:"+num);  
54.                 }  
55.              }  
56.          }catch (Exception e) {  
57.              e.printStackTrace();  
58.         }  
59.            
60.   
61.     }  
62.   
63.     /** 
64.      * 使用非递归的方式实现二分查找 
65.      * @param array 有序数组 
66.      * @param low 左下标 
67.      * @param high 右下标 
68.      * @param target 待查找的元素 
69.      * @return 
70.      */  
71.     public static int  binarySearch(int array[], int low, int high, int target){  
72.         while(low<=high){  
73.             int middle=(low+high)/2;  
74.             if(target>array[middle]){  
75.                 low=middle+1;  
76.             }else if(target<array[middle]){  
77.                 high=middle-1;  
78.             }else{  
79.                 return middle;  
80.             }  
81.         }  
82.         return -1;  
83.     }  
84.     /** 
85.      * 使用递归实现二分查找 
86.      * @param array 有序数组 
87.      * @param low 左下标 
88.      * @param high 右下标 
89.      * @param target 待查找的元素 
90.      * @return  
91.      */  
92.     public static int BSearch(int array[], int low, int high, int target ){  
93.         int middle=(low+high)/2;  
94.         if(low>high||target<array[low]||target>array[high]){  
95.             return -1;  
96.         }  
97.           
98.         if(target<array[middle]){  
99.             return BSearch(array,low,middle-1,target);  
100.         }else if(target>array[middle]){  
101.             return BSearch(array,middle+1,high,target);  
102.         }else{  
103.             return middle;  
104.         }  
105.     }  
106.       
107.     /** 
108.      * 顺序查找 
109.      * @param array 有序数组 
110.      * @param low 左下标 
111.      * @param high 右下标 
112.      * @param target 待查找的元素 
113.      * @return 
114.      */  
115.     public static int SSearch(int array[], int low, int high, int target ){  
116.         for(int i=low;i<high;i++){  
117.             if(target==array[i]){  
118.                 return i;  
119.             }  
120.         }  
121.         return -1;  
122.     }  
123. }  

 

运行结果如下：