java算法 library search_java 查找算法

// binarySearch.java

// demonstrates recursive binary search

// to run this program: C>java BinarySearchApp

class ordArray

{

private long[] a;                 // ref to array a

private int nElems;               // number of data items

//-----------------------------------------------------------

public ordArray(int max)          // constructor

{

a = new long[max];             // create array

nElems = 0;

}

//-----------------------------------------------------------

public int size()

{ return nElems; }

//-----------------------------------------------------------

public int find(long searchKey)

{

return recFind(searchKey, 0, nElems-1);

}

//-----------------------------------------------------------

private int recFind(long searchKey, int lowerBound,

int upperBound)

{

int curIn;

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)   // it's in upper half

return recFind(searchKey, curIn+1, upperBound);

else                       // it's in lower half

return recFind(searchKey, lowerBound, curIn-1);

}  // end else divide range

}  // end recFind()

//-----------------------------------------------------------

public void insert(long value)    // put element into array

{

int j;

for(j=0; j

if(a[j] > value)            // (linear search)

break;

for(int k=nElems; k>j; k--)    // move bigger ones up

a[k] = a[k-1];

a[j] = value;                  // insert it

nElems++;                      // increment size

}  // end insert()

//-----------------------------------------------------------

public void display()             // displays array contents

{

for(int j=0; j

System.out.print(a[j] + " ");  // display it

System.out.println("");

}

//-----------------------------------------------------------

}  // end class ordArray

class BinarySearchApp

{

public static void main(String[] args)

{

int maxSize = 100;             // array size

ordArray arr;                  // reference to array

arr = new ordArray(maxSize);   // create the array

arr.insert(72);                // insert items

arr.insert(90);

arr.insert(45);

arr.insert(126);

arr.insert(54);

arr.insert(99);

arr.insert(144);

arr.insert(27);

arr.insert(135);

arr.insert(81);

arr.insert(18);

arr.insert(108);

arr.insert(9);

arr.insert(117);

arr.insert(63);

arr.insert(36);

arr.display();                 // display array

int searchKey = 27;            // search for item

if( arr.find(searchKey) != arr.size() )

System.out.println("Found " + searchKey);

else

System.out.println("Can't find " + searchKey);

}  // end main()

}  // end class BinarySearchApp

// mergeSort.java

// demonstrates recursive merge sort

// to run this program: C>java MergeSortApp

class DArray

{

private long[] theArray;          // ref to array theArray

private int nElems;               // number of data items

//-----------------------------------------------------------

public DArray(int max)            // constructor

{

theArray = new long[max];      // create array

nElems = 0;

}

//-----------------------------------------------------------

public void insert(long value)    // put element into array

{

theArray[nElems] = value;      // insert it

nElems++;                      // increment size

}

//-----------------------------------------------------------

public void display()             // displays array contents

{

for(int j=0; j

System.out.print(theArray[j] + " ");  // display it

System.out.println("");

}

//-----------------------------------------------------------

public void mergeSort()           // called by main()

{                              // provides workspace

long[] workSpace = new long[nElems];

recMergeSort(workSpace, 0, nElems-1);

}

//-----------------------------------------------------------

private void recMergeSort(long[] workSpace, int lowerBound,

int upperBound)

{

if(lowerBound == upperBound)            // if range is 1,

return;                              // no use sorting

else

{                                    // find midpoint

int mid = (lowerBound+upperBound) / 2;

// sort low half

recMergeSort(workSpace, lowerBound, mid);

// sort high half

recMergeSort(workSpace, mid+1, upperBound);

// merge them

merge(workSpace, lowerBound, mid+1, upperBound);

}  // end else

}  // end recMergeSort()

//-----------------------------------------------------------

private void merge(long[] workSpace, int lowPtr,

int highPtr, int upperBound)

{

int j = 0;                             // workspace index

int lowerBound = lowPtr;

int mid = highPtr-1;

int n = upperBound-lowerBound+1;       // # of items

while(lowPtr <= mid && highPtr <= upperBound)

if( theArray[lowPtr] < theArray[highPtr] )

workSpace[j++] = theArray[lowPtr++];

else

workSpace[j++] = theArray[highPtr++];

while(lowPtr <= mid)

workSpace[j++] = theArray[lowPtr++];

while(highPtr <= upperBound)

workSpace[j++] = theArray[highPtr++];

for(j=0; j

theArray[lowerBound+j] = workSpace[j];

}  // end merge()

//-----------------------------------------------------------

}  // end class DArray

class MergeSortApp

{

public static void main(String[] args)

{

int maxSize = 100;             // array size

DArray arr;                    // reference to array

arr = new DArray(maxSize);     // create the array

arr.insert(64);                // insert items

arr.insert(21);

arr.insert(33);

arr.insert(70);

arr.insert(12);

arr.insert(85);

arr.insert(44);

arr.insert(3);

arr.insert(99);

arr.insert(0);

arr.insert(108);

arr.insert(36);

arr.display();                 // display items

arr.mergeSort();               // merge sort the array

arr.display();                 // display items again

}  // end main()

}  // end class MergeSortApp