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);
        }
    }
}