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

  1 package org.xiu68.ch02.ex2;
  2 
  3 import java.util.Random;
  4 import java.util.Scanner;
  5 
  6 public class Ex2_16 {
  7     public static final int ARR_MAX=1000000;
  8     //public static final int MIN=10000;
  9     public static void main(String[] args) {
 10         //无穷数组，前n个元素为整数且已排好序，n未知，剩下为无穷大，输入整数x，找到元素等于x的
 11         //位置（如果存在）
 12         
 13         //随机生成一个整数介于0~1000000之间作为数组中整数的长度，数组的长度为1000000。
 14         
 15         Random r=new Random();
 16         //int intLength=r.nextInt(ARR_MAX)%(ARR_MAX-MIN+1)+MIN;
 17         int intLength=r.nextInt(ARR_MAX);
 18         //构造一个数组，前n个元素为整数，剩下的为无穷大
 19         int[] arr=new int[ARR_MAX];
 20         for(int i=0;i<intLength;i++)
 21             arr[i]=r.nextInt(ARR_MAX);
 22         
 23         for(int i=intLength;i<arr.length;i++)
 24             arr[i]=Integer.MAX_VALUE;
 25         
 26         //对整数部分进行排序
 27         quitSort(arr, 0, intLength);
 28         
 29         //输入一个整数
 30         while(true){
 31         Scanner sc=new Scanner(System.in);
 32         System.out.println("输入一个整数：");
 33         int x=sc.nextInt();
 34         int result=search(arr,x,intLength);
 35         if(result==-1)
 36             System.out.println("不存在该值");
 37         else
 38             System.out.println("位置为:"+result);
 39         
 40         }
 41     }
 42     
 43     
 44     //查找，确定一个范围，然后进行折半查找
 45     public static int search(int[] r,int k,int intLength){
 46         if(r[0]==k)
 47             return 0;
 48         else{
 49             int t=r[1];
 50             int i=1;
 51             
 52             while(t<k){
 53                 try{
 54                 i=i*2;
 55                 t=r[i];
 56                 }catch(ArrayIndexOutOfBoundsException e){  //数组A[i]满足i>n
 57                     System.out.println("数组越界");
 58                     return -1;
 59                 }
 60                 
 61             }
 62             return biSearch(r, i/2, i, k);
 63         }
 64             
 65 
 66 }
 67     
 68     //快速排序划分算法
 69     public static int partition(int[] r,int i,int j){
 70         int temp=r[i];
 71         while(i<j){
 72             while(i<j && r[j]>=temp)    //从j向前找比temp小的值
 73                 j--;                
 74             
 75             if(i<j)
 76                 r[i++]=r[j]; //将j指向的值移到i的位置，i往后移一个位置
 77             
 78             while(i<j && r[i]<temp)        //从i向后找比temp大的值
 79                 i++;
 80             
 81             if(i<j)
 82                 r[j--]=r[i];
 83         }
 84         
 85         r[i]=temp;
 86         return i;
 87     }
 88     //快速排序算法
 89     public static void quitSort(int[] r, int i,int j){
 90         if(i<j){
 91             int middle=partition(r, i, j);
 92             quitSort(r, i, middle-1);
 93             quitSort(r, middle+1, j);
 94         }
 95     }
 96     
 97     //折半查找算法
 98     public static int biSearch(int[] r,int start,int end,int k){
 99         if(start>end)
100             return -1;
101         else{
102             int mid=(start+end)/2;
103             if(r[mid]==k)
104                 return mid;
105             else
106                 if(r[mid]<k)
107                     return biSearch(r,mid+1,end,k);
108                 else
109                     return biSearch(r,start,mid-1,k);
110         }
111     }
112 }