看了好几遍都看不懂，折半查找以后用的多吗，是不是必须得掌握，谁能够用简单的方法给我解释下啊

用的不多,其实排序用的都不多,一般都是面试上会问,但是还是建议学好一点!

1. class ArrayTest4//折半查找
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //定义一个数组
   
6.                 int[] arr={5,4,8,7,1,3,9};
   
7.                 //返回int类型的值,往里面传一个数组和要查找的元素
   
8.                 int index=halfSeek(arr,6);
   
9.                 //打印找到的元素位置
   
10.                 System.out.println(index);
    
11.         }
    
12.         //定义函数
    
13.         public static int halfSeek(int[] arr,int key)
    
14.         {
    
15.                 //定义变量.最大值最小值.和中间值
    
16.                 int max,min,mid;
    
17.                 max=arr.length-1;
    
18.                 min=0;
    
19.                 mid=(max+min)/2;
    
20.                 while(arr[mid]!=key)
    
21.                 {
    
22.                         //要查找的数大于中间值,最小值就等于中间值+1;
    
23.                         if(key>arr[mid])
    
24.                                 min=mid+1;
    
25.                         //要查找的数小于中间值,最大值就等于中间值-1;
    
26.                         else if(key<arr[mid])
    
27.                                 max=mid-1;
    
28.                         //如果最小值大于了最大值.就代表没有找到.则返回-1;
    
29.                         //ps.如果想要添加元素平且 有序的话就把-1改成min即可.
    
30.                         if(min>max)
    
31.                                 return min;
    
32.                         //每次循环都要从新定义中间值mid;要不然会一直查找.,程序不会停下来
    
33.                         mid=(max+min)/2;
    
34.                 }
    
35.                 //找到的话.就返回mid.也就是中间值
    
36.                 return mid;
    
37.         }
    
38. }

复制代码

折半最好还是掌握一点的比较好.下面是我加的注释.你应该能看懂

如果你有一个排好序的数组，用折半查找能提高效率。

折半查找，顾名思义，就是从中间开始查，小了直接查左边，不查右边了。大了直接查右边，不查左边了。这样来提高查询速度。

折半查找法是从数列的中间开始搜寻，如果这个数小于我们所搜寻的数，由于数列已排序，则该数左边的数一定都小于要搜寻的对象，所以无需浪费时间在左边的数；如果搜寻的数大于所搜寻的对象，则右边的数无需再搜寻，直接搜寻左边的数。

所以在二分搜寻法中，将数列不断的分为两个部份，每次从分割的部份中取中间数比对，例如要搜寻92于以下的数列，首先中间数索引为(0+9)/2 = 4（索引由0开始）：

[3 24 57 57 67 68 83 90 92 95]

由于67小于92，所以转搜寻右边的数列：

3 24 57 57 67 [68 83 90 92 95]

由于90小于92，再搜寻右边的数列，这次就找到所要的数了：

3 24 57 57 67 68 83 90 [92 95]
一定要记住二分查找法的数列是排好序的！

1. public class BinarySearch {
   
2. public static int search(int[] number, int des) {
   
3. int low = 0;
   
4. int upper = number.length - 1;
   
5. while (low <= upper) {
   
6. int mid = (low + upper) / 2;
   
7. if (number[mid] < des)
   
8. low = mid + 1;
   
9. else if (number[mid] > des)
   
10. upper = mid - 1;
    
11. else
    
12. return mid;
    
13. }
    
14. return -1;
    
15. }
    
16. 
    
17. public static void main(String[] args) {
    
18. int[] number = { 1, 4, 2, 6, 7, 3, 9, 8 };
    
19. QuickSort.sort(number);
    
20. int find = BinarySearch.search(number, 3);
    
21. if (find != -1)
    
22. System.out.println("找到数值于索引" + find);
    
23. else
    
24. System.out.println("找不到数值");
    
25. }
    
26. }
    

复制代码

择办查找好比一个猜字游戏，比如在1-100之内让你猜一个class Java
{
        public static int half(int []arr,int key)
        {
                 int min,max,mid;
                 min=0;
                 max=arr.length-1;
                 mid=(min+max)/2;
          while(arr[mid]!=key)
{   
                  if(key>arr[mid])
                      min=mid+1;
              else if(key<arr[mid])
                      max=mid-1;
              if(min>max)
                        return -1;意味着找不到目标，如果把-1改成min就现实这个数在这个数组中的位置。
                  


                   mid=(min+max)/2;取半继续找
          
}
     return mid;

          }
          
         public static void main(String []args)
        {   
         int []arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14};
         int dex=half(arr,12);
         System.out.println("dex="+dex);
         
         
         }
        }
class Java
{
        public static void main(String []args)
        {   
         int []arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14};
         int dex=half(arr,12);
         System.out.println("dex="+dex);
         
         
         }

        public static int half(int []arr,int key)
        {
                 int min,max,mid;
                 min=0;
                 max=arr.length-1;
                 mid=(min+max)/2;
          while(min<=max)
{   mid=(max+min)>>1;
                  if(key>arr[mid])
                      min=mid+1;
              else if(key<arr[mid])
                      max=mid-1;
              else  if(key==arr[mid])
                        return mid;
                  


                  
          
}
     return -1;

          }
          
       
        }
数90。你先以一半为目标，猜50。机器会说你猜的小了，你会继续猜 在51-100之内。就是在正确的空间内除以2查找。

择办查找好比一个猜字游戏，比如在1-100之内让你猜一个class Java
{
        public static int half(int []arr,int key)
        {
                 int min,max,mid;
                 min=0;
                 max=arr.length-1;
                 mid=(min+max)/2;
          while(arr[mid]!=key)
{   
                  if(key>arr[mid])
                      min=mid+1;
              else if(key<arr[mid])
                      max=mid-1;
              if(min>max)
                        return -1;意味着找不到目标，如果把-1改成min就现实这个数在这个数组中的位置。
                  


                   mid=(min+max)/2;取半继续找
          
}
     return mid;

          }
          
         public static void main(String []args)
        {   
         int []arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14};
         int dex=half(arr,12);
         System.out.println("dex="+dex);
         
         
         }
        }
class Java
{
        public static void main(String []args)
        {   
         int []arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14};
         int dex=half(arr,12);
         System.out.println("dex="+dex);
         
         
         }

        public static int half(int []arr,int key)
        {
                 int min,max,mid;
                 min=0;
                 max=arr.length-1;
                 mid=(min+max)/2;
          while(min<=max)
{   mid=(max+min)>>1;
                  if(key>arr[mid])
                      min=mid+1;
              else if(key<arr[mid])
                      max=mid-1;
              else  if(key==arr[mid])
                        return mid;
                  


                  
          
}
     return -1;

          }
          
       
        }
数90。你先以一半为目标，猜50。机器会说你猜的小了，你会继续猜 在51-100之内。就是在正确的空间内除以2查找。

折半 从中间拆开拿中间取出来这个元素和左右两边比较，前提是数组必须有序。

建议看一下二叉树的内容....
用二叉树的思想理解折半是很容易的...

就是提高查找速度...
有个bug就是不能有相同元素...
而且要有顺序的递增或者递减

对于折半查找我的理解是例如，1，2，3，4，5，6，7，8，9，10十个数，比如要找3，low指针指到1，high指针指到10，第一次mid指针指到5（（low+high）/2）；然后high指针变成4，mid指针变成2，这就找到。

建议看一下二叉树的内容....
用二叉树的思想理解折半是很容易的...

就是提高查找速度...
有个bug就是不能有相同元素...
而且要有顺序的递增或者递减

折半查找法也称为二分查找法，它充分利用了元素间的次序关系.它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。