算法入门---java语言实现的二分查找小结

1. package com.zy.serch;
3. public class BinarySerch {
6. /**
7. * 二分查找。
8. * 前提:数据源是有序的。
9. * 核心思想：还是先确定要写的算法的区间，此处我们是按照src[left...right],左闭右闭来查找的。
10. * 首先我们找到中间的索引mid,此时数据源就成了src[left...mid-1] [mid] [mid+1...right]
11. * 这样src[left...mid-1] < src[mid],src[mid+1...right] > src[mid].此时比较我们要查找
12. * 的数和mid索引所在的值:
13. * 等于: 找到直接返回
14. * 小于： 此时就应该在src[left...mid-1]据需执行相应的操作,
15. * 注意不需要再比较mid了,那么就是把right的索引做相应的处理。
16. * 大于： 此时就应该子啊src[mid+1...right]据需执行相应的操作,此次就需要对left索引做处理。
17. *
18. * 最终当left索引大于等于right索引的时候就不需要在进行查找了,此时仍没有找到的时候就返回-1，或其它的来标记未找到。
19. *
20. * 二分查找，当有相等的时候，那么按照查找规则，找到就会返回，不一定是前面的或者后面的。
21. * @param src 要进行查找的数据源
22. * @param value 要查找的值
23. * @return 如果数据存在返回找到的索引,否则返回-1;
24. *
25. */
26. public int binarySerch(int[] src,int value){
27. //老思想，确定自己的区间，定义需要维护的变量。
28. int len = src.length;
30. int left = 0;
31. int right = len-1;//由于我此处设计的是按照前闭后闭来看的。
33. //注意小于等于都符合我们区间控制，不操作等于的时候，最后只剩一个元素正好使我们
34. //要查找的就会遗漏
36. while(left <= right){
37. //
38. //int mid = (left+right)/2; 这种写法容易发生溢出，当两个大的int型的数相加时候范围是有可能超过int的
39. //所以用下面的写法。
40. int mid = left +(right-left)/2;
41. if(value == src[mid]){
42. return mid;
43. }else if(value > src[mid]){
44. //此时要查找的应该在右边部分所以
45. left = mid+1;
46. }else if(value < src[mid]){
47. //此时要查找的应该在左边部分所以
48. right = mid-1;
49. }
50. }
51. return -1;
52. }
54. /**
55. * 用递归的方法实现二分查找，核心思想是一样的。
56. * 不过递归实现时，考虑问题的角度的变，现在想每次的问题都是在一段区间内
57. * 从左向右找,然后递归的从左向右找，所以这个参数肯定也得传入左右的索引，
58. * 只不过这个索引会越来越小，直到不满足递归条件然后退出。
59. * @param src 数据源
60. * @param left 查找的区间的左索引
61. * @param right 查找的区间的右索引
62. * @param value 要查找的值
63. * @return 如果数据存在返回找到的索引,否则返回-1;
64. */
65. public int binarySerch(int[] src,int left,int right,int value){
66. //递归退出条件
67. if(left > right){
68. return -1;
69. }
70. int mid = left+(right-left)/2;
71. if(value == src[mid]){
72. return mid;
73. }
74. if(value > src[mid]){
75. left = left+1;
76. //下面应该直接进入到另一个函数进行查询，进入以后这个函数就执行完了，然后
77. //自动销毁了，然后就去那个函数中接着执行，所以就是一层一层的，递归的设计思想
78. //直到某个函数中找到了，不再调用此处了，或者某个函数不满足递归条件了直接退出。
79. return binarySerch(src, left, right, value);
80. }else{
81. right = mid-1;
82. return binarySerch(src, left, right, value);
83. }
84. //return -1;这就不该有了，现在理解的还不到位。
85. }
87. }

  递归实现的二分查找可能性能上会略差，不过都是logn的时间复杂度。慕课网上的图

 

二分查找实现的floor操作(慕课网的)

1. /**
2. * 理解的还不够透彻
3. * 对value向下取数核心思想：
4. * 从src[left...right],中开始查找.先计算mid
5. * 当src[mid]大于或者等于value的时候, 让right的索引减一,因为我们要找小于或者等于的。
6. * 当src[mid]小于value的时候，那么直接把left放在在mid的索引(不放在mid+1怕大于right)
7. * 就这样在left < right的条件下一只进行次操作，那么最后出来的时候就是我们要找的最大的小于value的值的索引。
8. *
9. * @param src 数据源
10. * @param value 进行floor操作的值。
11. * @return 返回在数组中找到的value的floor值：
12. * 1)、找到该value的时候直接返回。
13. * 2)、没有找到的时候返回比value小的最大值的索引,如果这个索引最大值有多个，那么返回最大索引(从
14. * 右往左一步步减少)
15. * 3)、如果整个数组的最小值都比value大，那么不存在value的floor值返回-1.
16. */
17. public int floor(int[] src, int value){
18. int len = src.length;
20. //左闭右闭的区间找,
21. int left = 0;
22. int right = len-1;
23. //如果最小的元素都比当前的元素小那么就返回-1；
24. if(src[0] > value){
25. return -1;
26. }
27. //等于时就证明我们已经走到了我们的条件的索引
28. while(left < right){
29. //使用mid = left+(right-left)/2会死循环
30. //因为假设我们一直查找到了两个数相邻的时候，设为A 、B
31. //我们要查找的数value等于B, 此时A < B 在数组中有序相邻排列。
32. //left索引、righ索引分别对应于A和B。那么mid =(如上) 永远是等于left所在的索引
33. //而此时left索引对应的元素小于value，需要把mid的值再赋值给left，再进行求mid，如此进入了死循环
34. //因为right索引不会动。
35. //所以我们使用int mid = left+(right-left)/2,这种求mid的方法。
36. //这种求mid的方法奇数时候没什么影响，在偶数的是后会向上取一个数如：
37. // 0 1 2 3 的时候会取 2,而我们以前会取1.但是在奇数的时候如
38. //0 1 2 3 4 5 依然是取3没什么影响。
39. //综上：当我们使用mid = left+(right-left)/2时候，再出现如上两个数相邻的状况，我们会取到
40. //right的数，而right的索引无论是在大于还是等于value的时候都会对mid进行减1.这样while的判断
41. //条件left < right就不符合了，会退出循环。
42. //mid = left+(right-left)/2 案例例如：
43. //int[] src = {5 ,23 ,29 ,30 ,33,33 ,35 ,39 ,53 ,56 ,70 ,74 ,81 ,82 ,87 ,87 };
44. //第一次:0+(15-0)/2 = 7
45. //src[7] = 39 < value;left = 7
46. //第二次:7+(15-7)/2 = 11.
47. //src[11] = 74 > value;right = 10
48. //第三次：7+(10-7)/2 = 8;
49. //src[8] = 53 < value;left = 8
50. //第四次：8+(10-8)/2 = 9;
51. //src[9] = 56 < value;left = 9
52. //第五次：9+(10-9)/2 = 9;
53. //src[9] = 56 < value;left = 9
54. //接下来一直无限循环。
56. int mid = left+(right-left+1)/2;
58. if(src[mid] >= value){
59. //大于等于的时候mid减一，往前面走一个
60. right = mid - 1;
61. }else{
62. //当小于的时候此处直接把left设置为mid，大范围减少查找的量
63. left = mid;
64. }
65. }
66. System.out.println("left = "+left+",right = "+right);
67. //此处出来的时候left是等于right的
68. //此时由于等于的时候我们队right进行了减1.那么有可能后一个数是等于的所以执行如下操作
69. if( left + 1 < len && src[left+1] == value )
70. return left + 1;
72. // 否则, 该索引即为返回值
73. return left;
74. }

二分查找实现的ceil(慕课网上的)

1. /**
2. * 理解的也不够透彻
3. * 对value向上取数核心思想：
4. * 从src[left...right],中开始查找.先计算mid.
5. * 当src[mid]小于或者等于value的时候, 让left的索引加1。
6. * 当src[mid]大于value的时候，那么直接把right放在mid的索引。
7. * 就这样在left < right的条件下一直进行次操作，那么最后出来的时候就是我们要找的最大的小于value的值的索引。
8. * @param src 数据源.
9. * @param value 进行ceil操作的值.
10. * @return 返回在数组中找到的value的ceil值：
11. * 1)、找到该value的时候直接返回。
12. * 2)、没有找到的时候返回比value大的小大值的索引,如果这个索引最小值有多个，那么返回最小索引(从左
13. * 往右一步步减少)
14. * 3)、如果整个数组的最大值都比value小，那么不存在value的floor值返回-1.
15. */
16. public int ceil(int[] src, int value){
17. int len = src.length;
19. //左闭右闭的区间找,
20. int left = 0;
21. int right = len-1;
22. //如果最小的元素都比当前的元素小那么就返回-1；
23. if(src[right] < value){
24. return -1;
25. }
26. while( left < right ){
27. //此处动的是左边索引，所以正好不会出现死循环。
28. int mid = left + (right-left)/2;
29. if( src[mid] <= value )
30. left = mid + 1;
31. else
32. right = mid;
33. }
35. if( right - 1 >= 0 && src[right - 1] == value )
36. return right - 1;
38. //该索引即为返回值
39. return right;
40. }