Ex 2_16 给定一个无穷数组..._第二次作业

先比较数组的A[0]元素，若不相等接下来比较A[1],A[2],A[4],A[8]…,若找到一个区间A[2^n-1]<x<A[2ⁿ],再对这个区间进行折半查找操作。总的时间为O(logn)。

若查找过程中A[i]中的i>n,则抛出异常

 package org.xiu68.ch02.ex2;

 import java.util.Random;
 import java.util.Scanner;

 public class Ex2_16 {
     public static final int ARR_MAX=1000000;
     //public static final int MIN=10000;
     public static void main(String[] args) {
         //无穷数组，前n个元素为整数且已排好序，n未知，剩下为无穷大，输入整数x，找到元素等于x的
         //位置（如果存在）

         //随机生成一个整数介于0~1000000之间作为数组中整数的长度，数组的长度为1000000。

         Random r=new Random();
         //int intLength=r.nextInt(ARR_MAX)%(ARR_MAX-MIN+1)+MIN;
         int intLength=r.nextInt(ARR_MAX);
         //构造一个数组，前n个元素为整数，剩下的为无穷大
         int[] arr=new int[ARR_MAX];
         for(int i=0;i<intLength;i++)
             arr[i]=r.nextInt(ARR_MAX);

         for(int i=intLength;i<arr.length;i++)
             arr[i]=Integer.MAX_VALUE;

         //对整数部分进行排序
         quitSort(arr, 0, intLength);

         //输入一个整数
         while(true){
         Scanner sc=new Scanner(System.in);
         System.out.println("输入一个整数：");
         int x=sc.nextInt();
         int result=search(arr,x,intLength);
         if(result==-1)
             System.out.println("不存在该值");
         else
             System.out.println("位置为:"+result);

         }
     }

     //查找，确定一个范围，然后进行折半查找
     public static int search(int[] r,int k,int intLength){
         if(r[0]==k)
             return 0;
         else{
             int t=r[1];
             int i=1;

             while(t<k){
                 try{
                 i=i*2;
                 t=r[i];
                 }catch(ArrayIndexOutOfBoundsException e){  //数组A[i]满足i>n
                     System.out.println("数组越界");
                     return -1;
                 }

             }
             return biSearch(r, i/2, i, k);
         }

 }

     //快速排序划分算法
     public static int partition(int[] r,int i,int j){
         int temp=r[i];
         while(i<j){
             while(i<j && r[j]>=temp)    //从j向前找比temp小的值
                 j--;                

             if(i<j)
                 r[i++]=r[j]; //将j指向的值移到i的位置，i往后移一个位置

             while(i<j && r[i]<temp)        //从i向后找比temp大的值
                 i++;

             if(i<j)
                 r[j--]=r[i];
         }

         r[i]=temp;
         return i;
     }
     //快速排序算法
     public static void quitSort(int[] r, int i,int j){
         if(i<j){
             int middle=partition(r, i, j);
             quitSort(r, i, middle-1);
             quitSort(r, middle+1, j);
         }
     }

     //折半查找算法
     public static int biSearch(int[] r,int start,int end,int k){
         if(start>end)
             return -1;
         else{
             int mid=(start+end)/2;
             if(r[mid]==k)
                 return mid;
             else
                 if(r[mid]<k)
                     return biSearch(r,mid+1,end,k);
                 else
                     return biSearch(r,start,mid-1,k);
         }
     }
 }