算法分析与设计实验报告 ——二分搜索程序算法的实现_二分搜索算法实验报告

算法分析与设计实验报告

——二分搜索程序算法的实现

实验目的及要求

1.理解分治算法的概念和基本要素；
2.理解递归的概念；
3.掌握设计有效算法的分治策略；
4.通过二分搜索技术学习分治策略设计技巧；

实验环境

操作系统：Windows 10 操作系统
开发工具：Eclipse(4.15.0)
开发语言：Java

实验内容

1.使用二分搜索算法查找有序数列中的指定元素；
2.通过上机实验进行算法实现；
3.保存和打印出程序的运行结果，并结合程序进行分析，上交实验报告。

算法描述及实验步骤

实验步骤：

1. 编写二分搜索算法；
2. 将输入的数组元素排序，转化成有序列；
3. 编写输入输出；
4. 测试结果。

调试过程及实验结果

问题1：编写递归方法时返回的边界错误，导致陷入死循环。如
return RecursionBinarySearch(arr,key,left,middle);//搜索左半区
return RecursionBinarySearch(arr,key,middle,right);//搜索右半区

正确修改：return RecursionBinarySearch(arr,key,left,middle-1);
return RecursionBinarySearch(arr,key,middle+1,right);

问题2：编写迭代方法时while()的条件写成while(left<right)遗漏等号，导致搜索值key=arr[arr.length]时，输出“未搜索到key”。
正确修改：while(left<=right)
输出结果为：

总结

元素存储在数组中，因此搜索输出的结果为有序数组元素的下标。
若有序列中存在重复元素，搜索结果输出第一个元素的下标。
对二分搜索算法的边界问题要考虑清楚， 循环体外的初始条件与循环体内的步骤一定要遵守一致的区间规则（左右开闭），否则会发生陷入死循环、无法找到搜索元素的错误。
二分搜索算法是将数列按有序化排列，查找过程中采用跳跃式方式查找，先以有序数列的中点位置为比较对象，如果查找的元素值小于中点元素（key<middle），则将待查序列缩小为左半区间，否则为右半区间，直到找到相同元素，或者查找范围为空。
二分搜索算法的优点是比较次数少，查找速度快，平均性能好；缺点是要求待查表为有序表，且插入删除困难。

源代码

import java.util.Scanner;
public class BinarySearch{	
	public static int RecursionBinarySearch(int[] arr , int key , int left , int right)
	{	//递归
		if((key<arr[left]||(key>arr[right])||(right>right)))
				return -1;
		int middle =(left &right) + ((left ^ right) >> 1); //防溢出(left &right) + ((left ^ right) >> 1);
		if(key<arr[middle])
		{
			return RecursionBinarySearch(arr,key,left,middle-1);//搜索左半区
		}
		else if(key>arr[middle]) 
		{
			return RecursionBinarySearch(arr,key,middle+1,right);//搜索右半区
		}
		else
		{
			return middle;
		}
	}
	
	public static int CommonBinarySearch(int[] arr,int key) 
	{	//迭代
		int left = 0;
		int right = arr.length-1;
		int middle = 0;
		if((key<arr[left])||(key>arr[right]))
			return -1;
		while(left<=right)  
			{
				middle =(left &right) + ((left ^ right) >> 1);
				if(key==arr[middle])
					return middle;
				else if(key<arr[middle])
					right = middle-1;//左半区搜索
				else if(key>arr[middle])
					left = middle+1;//右半区搜索
			}
		return -1;//未搜索到目标key返回-1
	}
	
	public static int[] Selectionsort(int[] arr) 
	{//选择排序
		for(int i=0;i<arr.length-1;i++)
		{
			int min = i;
			for(int j=i+1;j<arr.length;j++)
			{
				if(arr[j]<arr[min])
					min = j;
			}
			if(i!=min) 
			{
				int temp=arr[i];
				arr[i]=arr[min];
				arr[min]=temp;
			}
		}
		return arr;
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("输入元素个数：");
		int n = sc.nextInt();
		int position;
		
		int[] arr = new int[n];//输入数组元素
		for(int i=0;i<n;i++)
		{
			System.out.print(i+"号元素为：");
			arr[i] = sc.nextInt();
		}
		
		Selectionsort(arr);//选择排序数组元素
		System.out.println("选择排序(升序)后有序列为：");
		for(int i=0;i<arr.length;i++)
		{
			System.out.print(arr[i]+" ");
		}
		System.out.println("");
		
		do {
			System.out.println("输入查找元素key：");
			int key =sc.nextInt();
			//递归搜索
			 position = RecursionBinarySearch(arr,key,0,arr.length-1);
			if(position==-1)
			{
				System.out.println("查找"+key+",有序列中不存在");
			}
			else
			{
				System.out.println("查找"+key+"（递归）\n"+"在有序列中的位置为："+position);
			}
			//迭代搜索
			  position = CommonBinarySearch(arr,key);
			if(position==-1)
			{
				System.out.println("查找"+key+",有序列中不存在");
			}
			else
			{
				System.out.println("查找"+key+"(迭代)\n"+"在有序列中的位置为："+position);
			}
			
		}while(true);
		
	}
	
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113