服务计算概论作业报告材料

* @author Mark Allen Weiss
*/
public final class Sorting
{
/**
* Simple insertion sort.
* @param a an array of Comparable items.
*/
public void insertionSort( int[ ] a )
}
private static final int CUTOFF = 10;
public static final void swapReferences( Object [ ] a, int index1, int index2 )
{
Object tmp = a[ index1 ];
a[ index1 ] = a[ index2 ];
{
int j;
for( int p = 1; p < a.length; p++ )
{
int tmp = a[ p ];
for( j = p; j > 0 && tmp<a[ j - 1 ]; j-- )
a[ j ] = a[ j - 1 ];
a[ j ] = tmp;
}
}
public boolean isSorted(int[] a) {
{
int center = ( left + right ) / 2;
if( a[ center ]<a[ left ] )
swap( a, left, center );
if( a[ right ] < a[ left ] )
swap( a, left, right );
if( a[ right ] < a[ center ] )
if(i*2 <= currentSize && array[i]>array[2*i]) {
returnfalse;
}
if(i*2 + 1<= currentSize && array[i]>array[2*i+1]) {
returnfalse;
}
}
returntrue;
}
/**
* Remove the smallest item from the priority queue.
{
returncurrentSize == array.length - 1;
}
/**
* Make the priority queue logically empty.
*/
//@ ensures isEmpty();
publicvoidmakeEmpty( )
{
currentSize = 0;
}
privatestaticfinalintDEFAULT_CAPACITY= 100;
// boolean isEmpty( ) --> Return true if empty; else false
// boolean isFull( ) --> Return true if full; else false
// void makeEmpty( ) --> Remove all items
percolateDown( 1 );
returnminItem;
}
/**
* Establish heap order property from an arbitrary
* arrangement of items. Runs in linear time.
*/
publicvoidbuildHeap( )
* such as stacks, queues, and priority queues.
*@authorMarkAllenWeiss
*/
publicclassOverflowextendsException
{
}
题目（2）
import parator;
import java.util.Random;
*@authorMarkAllenWeiss
*/
publicclassBinaryHeap
{
//@ invariant wellFormed();
/**
* Construct the binary heap.
*/
publicBinaryHeap( )
{
this(DEFAULT_CAPACITY);
}
swap( a, center, right );
// Place pivot at position right - 1
swap( a, center, right - 1 );
return a[ right - 1 ];
}
private static void quicksort( int[ ] a, int left, int right)
/**
* A class that contains several sorting routines,
* implemented as static methods.
* Arrays are rearranged with smallest item first,
* using compareTo.
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x ) --> Insert x
//intdeleteMin( )--> Return and remove smallest item
//intfindMin( ) --> Return smallest item
array[ child + 1 ]< array[ child ] )
child++;
if( array[ child ]< tmp )
array[ hole ] = array[ child ];
else
break;
}
array[ hole ] = tmp;
}
}
/**
* Exception class for access in full containers
*@returnthe smallest item, or null, if empty.
*/
publicintdeleteMin( )
{
if( isEmpty( ) )
return-1;
intminItem = findMin( );
array[ 1 ] = array[ currentSize-- ];
*/
publicbooleanisEmpty( )
{
returncurrentSize == 0;
}
/**
* Test if the priority queue is logically full.
*@returntrue if full, false otherwise.
*/
publicbooleanisFull( )
returnfalse;
}
if(currentSize<0 || currentSize>=array.length) {//currentSize>=0; currentSize<array.length;
returnfalse;
}
for(inti=1; i<currentSize; i++) {
// ***************************
// Throws Overflow if capacity exceeded
/**
* Implements a binary heap.
* Note that all "matching" is based on the compareTo method.
{
for(inti = currentSize / 2; i > 0; i-- )
percolateDown( i );
}
/**
* Test if the priority queue is logically empty.
*@returntrue if empty, false otherwise.
*/
privatevoidpercolateDown(inthole )
{
intchild;
inttmp = array[ hole ];
for( ; hole * 2 <= currentSize; hole = child )
{
child = hole * 2;
if( child != currentSize &&
{
if( left + CUTOFF <= right )
{
int pivot = median3( a, left, right );
int i = left, j = right - 1;
for( ; ; )
{
while( a[ ++i ] < pivot ) { }
for( ; hole > 1 && x< array[ hole / 2 ]; hole /= 2 )
array[ hole ] = array[ hole / 2 ];