java实现Binary Search

// orderedArray.java
// demonstrates ordered array class
// to run this program: C>java OrderedApp
import java.io.*; // for I/O

class OrdArray
{
private double[] a; // ref to array a
private int nElems; // number of data items
//----------------------------------------------------------
-
public OrdArray(int max) // constructor
{
a = new double[max]; // create array
nElems = 0;
}
//----------------------------------------------------------
-
public int size()
{ return nElems; }
//----------------------------------------------------------
- core algorithm
public int find(double searchKey)
{
int lowerBound = 0;
int upperBound = nElems-1;
int curIn;
while(true)
{
curIn = (lowerBound + upperBound ) / 2;
if(a[curIn]==searchKey)
return curIn; // found it else
if(lowerBound > upperBound)
return nElems; // can't find it
else // divide range
{
if(a[curIn] < searchKey)
lowerBound = curIn + 1; // it's in upper half
else
upperBound = curIn - 1; // it's in lower half
} // end else divide range
} // end while
- 51 -
} // end find()
//----------------------------------------------------------
-
public void insert(double value) // put element into array
{
int j;
for(j=0; j<nElems; j++) // find where it goes
if(a[j] > value) // (linear search)
break;
for(int k=nElems; k>j; k--) // move higher ones up
a[k] = a[k-1];
a[j] = value; // insert it
nElems++; // increment size
} // end insert()
//----------------------------------------------------------
-
public boolean delete(double value)
{
int j = find(value);
if(j==nElems) // can't find it
return false;
else // found it
{
for(int k=j; k<nElems; k++) // move higher ones down
a[k] = a[k+1];
nElems--; // decrement size
return true;
}
} // end delete()
//----------------------------------------------------------
-
public void display() // displays array contents
{
for(int j=0; j<nElems; j++) // for each element,
System.out.print(a[j] + " "); // display it
System.out.println("");
}
//----------------------------------------------------------
-
} // end class OrdArray

class OrderedApp
{
public static void main(String[] args)
{
int maxSize = 100; // array size
OrdArray arr; // reference to array
arr = new OrdArray(maxSize); // create the array
- 52 -
arr.insert(77); // insert 10 items
arr.insert(99);
arr.insert(44);
arr.insert(55);
arr.insert(22);
arr.insert(88);
arr.insert(11);
arr.insert(00);
arr.insert(66);
arr.insert(33);
int searchKey = 55; // search for item
if( arr.find(searchKey) != arr.size() )
System.out.println("Found " + searchKey);
else
System.out.println("Can't find " + searchKey);
arr.display(); // display items
arr.delete(00); // delete 3 items
arr.delete(55);
arr.delete(99);
arr.display(); // display items again
} // end main()

} // end class OrderedApp

Advantages of Ordered Arrays
What have we gained by using an ordered array? The major advantage is that search
times are much faster than in an unordered array. The disadvantage is that insertion
takes longer, because all the data items with a higher key value must be moved up to
make room. Deletions are slow in both ordered and unordered arrays, because items
must be moved down to fill the hole left by the deleted item.
Ordered arrays are therefore useful in situations in which searches are frequent, but
insertions and deletions are not. An ordered array might be appropriate for a database of
company employees, for example. Hiring new employees and laying off existing ones
would probably be infrequent occurrences compared with accessing an existing
employee's record for information or updating it to reflect changes in salary, address, and
so on.