commit a231da731dce55218da4cbfb3ec4a2ce40b3fa8e Author: mercury Date: Wed Dec 3 17:41:26 2003 +0000 Initial revision diff --git a/CD.java b/CD.java new file mode 100644 index 0000000..4c3d1c2 --- /dev/null +++ b/CD.java @@ -0,0 +1,83 @@ +//******************************************************************** +// CD.java Author: Lewis and Loftus +// +// Represents a compact disc. +//******************************************************************** + +import java.text.DecimalFormat; + +public class CD implements Comparable, Radixable +{ + private String title, artist; + private double value; + private int tracks; + + //----------------------------------------------------------------- + // Creates a new CD with the specified information. + //----------------------------------------------------------------- + public CD (String theTitle, String theArtist, double theValue, int theTracks) + { + title = theTitle; + artist = theArtist; + value = theValue; + tracks = theTracks; + } + + //----------------------------------------------------------------- + // Returns a description of this CD. + //----------------------------------------------------------------- + public String toString() + { + DecimalFormat fmt=new DecimalFormat("0.00"); + String description = "$" + fmt.format(value) + " " + tracks + " " + title + " " + artist; + return description; + } + + public String getTitle() + { + return title; + } + + public double getPrice() + { + return value; + } + + public String getArtist() + { + return artist; + } + + public int getTracks() + { + return tracks; + } + + public void setTracks(int tempTracks) + { + tracks=tempTracks; + } + + public void setPrice(double tempPrice) + { + value=tempPrice; + } + + public int compareTo (Object other) + { + //define the way that CD's are compared-- in this case, alphabetically by title + //comparing the objects is reduced to comparing the strings that make up the title + int result; + result = (this.getTitle().toLowerCase().compareTo( ((CD) other).getTitle().toLowerCase() )); + return result; + } + + public char getRadixChar(int index) { + try { + return title.charAt(index); + } + catch (StringIndexOutOfBoundsException e) { + return ' '; + } + } +} diff --git a/Data.java b/Data.java new file mode 100644 index 0000000..7c188fd --- /dev/null +++ b/Data.java @@ -0,0 +1,31 @@ +public class Data +{ + + private double x; + private double y; + + public Data(double x,double y) + { + this.x=x; + this.y=y; + } + + public double getX() + { + return x; + } + + public double getY() + { + return y; + } + + public boolean equals(Data otherData) + { + if (x==otherData.getX() && y==otherData.getY()) + return true; + else + return false; + } + +} \ No newline at end of file diff --git a/DataVector.java b/DataVector.java new file mode 100644 index 0000000..0bee087 --- /dev/null +++ b/DataVector.java @@ -0,0 +1,63 @@ +import java.util.*; +import java.awt.Color; + +public class DataVector +{ + + private Vector myVector; + private int size; + private Color myColor; + private String title; + + public DataVector(String title,Color myColor) + { + this.title=title; + myVector=new Vector(); + size=0; + this.myColor=myColor; + } + + public void addPoint(double x, double y) + { + myVector.add(new Data(x,y)); + size++; + } + + public double getX(int index) + { + return ((Data) myVector.elementAt(index)).getX(); + } + + public double getY(int index) + { + return ((Data) myVector.elementAt(index)).getY(); + } + + public int size() + { + return size; + } + + public String getTitle() + { + return title; + } + + public Color getColor() + { + Color temp=new Color(myColor.getRed(),myColor.getGreen(),myColor.getBlue()); + return temp; + } + + public void removePoint(double x, double y) + { + Data temp=new Data(x,y); + + for (int z=0;z= maxList) + { + //throw new ListException("List full."); + arrayResize(); + } // end if + + if (index >= 1 && index <= size+1) + { + // make room for new element by shifting all items at + // positions >= index toward the end of the + // list (no shift if index == size+1) + for (int pos = size; pos >= index; pos--) + { + items[pos] = items[pos-1]; + } // end for + // insert new item + items[index-1] = item; + size++; + } + else + { // index out of range + throw new ListException("List index out of range."); + } // end if + + } //end add + + public Object get(int index) throws ListException + { + + if (index >= 1 && index <= size) + { + return items[index-1]; + } + else + { // index out of range + throw new ListException("List index out of range."); + } // end if + + } // end get + + public void remove(int index) throws ListException + { + if (index >= 1 && index <= size) + { + // delete item by shifting all items at + // positions > index toward the beginning of the list + // (no shift if index == size) + for (int pos = index; pos < size(); pos++) + { + items[pos-1] = items[pos]; + } // end for + items[size()-1]=null; //eliminate dangling references + size--; + } + else + { // index out of range + throw new ListException("List index out of range."); + } // end if + } //end remove + + private void arrayResize() + { + maxList*=2; + Object[] temp=new Object[maxList]; + + for (int x=0;xListInterface provides the user interface for the general list. + * + * @author + * Mark Boshart + * @version 1.0 + */ +public interface ListInterface +{ + /** + * Determines whether a list is empty.
+ * Precondition: None.
+ * Postcondition: Returns true if the list is empty, otherwise returns false.
+ * Throws: None. + */ + public boolean isEmpty(); + + /** + * Determines the length of a list.
+ * Precondition: None.
+ * Postcondition: Returns the number of items that are currently in the list.
+ * Throws: None. + */ + public int size(); + + /** + * Adds an item to the list at position index.
+ * Precondition: index indicates the position at which the item should be inserted in the list.
+ * Postcondition: If insertion is successful, item is at position index in the list, and other items are renumbered accordingly.
+ * Throws: ListException if index < 1 or index > size()+1.
+ * Throws: ListException if item cannot be placed on the list. + * + * @param index int position to insert the object. + * @param item Object object to be inserted. + */ + public void add(int index, Object item) throws ListException; + + /** + * Retrieves a list item by position.
+ * Precondition: index is the number of the item to be retrieved.
+ * Postcondition: If 1 <= index <= size(), the item at position index in the list is returned.
+ * Throws: ListException if index < 1 or index > size().
+ * + * @param index int position to retrieve the object. + */ + public Object get(int index) throws ListException; + + /** + * Deletes an item from the list at a given position.
+ * Precondition: index indicates where the deletion should occur.
+ * Postcondition: If 1 <= index <= size(), the item at position index in the list is deleted, and other items are renumbered accordingly.
+ * Throws: ListException if index < 1 or index > size().
+ * + * @param index int position to remove the object. + */ + public void remove(int index) throws ListException; + + /** + * Deletes all the items from the list.
+ * Precondition: None.
+ * Postcondition: The list is empty.
+ * Throws: None. + */ + public void removeAll(); + + /** + * Returns an Iterator for the list.
+ * Precondition: None.
+ * Postcondition: An Iterator is returned.
+ * Throws: None. + */ + public Iterator iterator(); + +} // end ListInterface diff --git a/ListIterator.java b/ListIterator.java new file mode 100644 index 0000000..c20a056 --- /dev/null +++ b/ListIterator.java @@ -0,0 +1,54 @@ + +import java.util.Iterator; + +class ListIterator implements Iterator +{ + private int index; + private int check; + private ListInterface list; + + public ListIterator(ListInterface list) + { + index=1; + check=list.size(); + this.list=list; + } + + private void check() + { + if (check!=list.size()) + { + //reset iteration to the start of the list + index=1; + check=list.size(); + throw new ListException("Change made to collection during iteration."); + //check can miss alterations to the list if add/remove combinations are used + } + } + + public void remove() + { + //to be implemented + } + + public boolean hasNext() + { + check(); + return (index<=check); + } + + public Object next() + { + check(); + + if (hasNext()) + { + index++; + return list.get(index-1); + } + else + { + throw new ListException("End of list."); + } + } +} \ No newline at end of file diff --git a/Node.java b/Node.java new file mode 100644 index 0000000..686cb9a --- /dev/null +++ b/Node.java @@ -0,0 +1,30 @@ +public class Node { + private Node next; + private Object data; + public Node(Object data) { + this.data = data; + next = null; + } + + public Node(Object data, Node next) { + this.data = data; + this.next = next; + } + + public Object getItem() { + return data; + } + + public void setItem(Object data) { + this.data = data; + } + + public Node getNext() { + return next; + } + + public void setNext(Node next) { + this.next = next; + } + +} \ No newline at end of file diff --git a/QueueException.java b/QueueException.java new file mode 100644 index 0000000..9e9a8d6 --- /dev/null +++ b/QueueException.java @@ -0,0 +1,9 @@ + +public class QueueException extends RuntimeException +{ + public QueueException(String s) + { + super(s); + } // end constructor +} // end QueueException + diff --git a/QueueInterface.java b/QueueInterface.java new file mode 100644 index 0000000..d034251 --- /dev/null +++ b/QueueInterface.java @@ -0,0 +1,59 @@ + +public interface QueueInterface +{ + /** + * Determines whether a queue is empty. + * Precondition: None. + * Postcondition: Returns true if the queue is empty; + * otherwise returns false. + */ + public boolean isEmpty(); + + /** + * Adds an item at the back of a queue. + * Precondition: item is the item to be inserted. + * Postcondition: If the operation was successful, newItem + * is at the back of the queue. Some implementations + * may throw QueueException if item cannot be added to the queue. + */ + public void enqueue(Object item) throws QueueException; + + /** + * Retrieves and removes the front of a queue. + * Precondition: None. + * Postcondition: If the queue is not empty, the item + * that was added to the queue earliest is returned and + * the item is removed. If the queue is empty, the + * operation is impossible and QueueException is thrown. + */ + public Object dequeue() throws QueueException; + + /** + * Removes all items of a queue. + * Precondition: None. + * Postcondition: The queue is empty. + */ + public void dequeueAll(); + + /** + * Retrieves the item at the front of a queue. + * Precondition: None. + * Postcondition: If the queue is not empty, the item + * that was added to the queue earliest is returned. + * If the queue is empty, the operation is impossible + * and QueueException is thrown. + */ + public Object peek() throws QueueException; + + /** + * Determines the length of a queue. + * Precondition: None. + * Postcondition: Returns the number of items that are + * currently in the queue. + * Throws: None. + */ + public int size(); + + +} // end QueueInterface + diff --git a/QueueReferenceBased.java b/QueueReferenceBased.java new file mode 100644 index 0000000..54cbe2d --- /dev/null +++ b/QueueReferenceBased.java @@ -0,0 +1,103 @@ + +public class QueueReferenceBased implements QueueInterface +{ + // circular references + private Node tail; + private int size; + + public QueueReferenceBased() + { + tail = null; + size=0; + } // end default constructor + + // queue operations: + public boolean isEmpty() + { + return tail == null; + } // end isEmpty + + public int size() + { + return size; + } + + public void dequeueAll() + { + if (tail!=null) + tail.setNext(null); + + tail = null; + size=0; + } // end dequeueAll + + public void enqueue(Object item) + { + Node myNode = new Node(item); + + // insert the new node + if (isEmpty()) + { + // insertion into empty queue + myNode.setNext(myNode); + } + else + { + // insertion into nonempty queue + myNode.setNext(tail.getNext()); + tail.setNext(myNode); + } // end if + + tail = myNode; // new node is at back + size++; + } // end enqueue + + public Object dequeue() throws QueueException + { + if (!isEmpty()) + { + // queue is not empty; remove front + Node head = tail.getNext(); + if (head == tail) + { // special case? + tail.setNext(null); + tail = null; // yes, one node in queue + } + else + { + tail.setNext(head.getNext()); + } // end if + size--; + return head.getItem(); + } + else + { + throw new QueueException("Queue empty"); + } // end if + } // end dequeue + + public Object peek() throws QueueException + { + if (!isEmpty()) + { + // queue is not empty; retrieve front + Node head = tail.getNext(); + return head.getItem(); + } + else + { + throw new QueueException("Queue empty"); + } // end if + } // end peek + + public String toString() { + Node temp = tail.getNext(); + String result = ""; + for (int i = 0; i < size; i++) { + result += temp.getItem() + "\n"; + temp = temp.getNext(); + } + return result; + } + +} // end QueueCircular \ No newline at end of file diff --git a/Radixable.java b/Radixable.java new file mode 100644 index 0000000..c15be5f --- /dev/null +++ b/Radixable.java @@ -0,0 +1,12 @@ +/** + * An interface for making objects easy to sort Radixably.
+ * @author Andrew Coleman + */ +public interface Radixable { + /** + * The only method needed to sort objects Radixably.
+ * Preconditions: An index in the name that is being used to sort. + * Postconditions: Returns a char at the index, or a space if the index is invalid. + */ + public char getRadixChar(int index); +} \ No newline at end of file diff --git a/SortRoutines.java b/SortRoutines.java new file mode 100644 index 0000000..89b604e --- /dev/null +++ b/SortRoutines.java @@ -0,0 +1,401 @@ +//import trees.*; +//import queues.*; + +public class SortRoutines +{ + + + // Finds the largest item in an array. + // Precondition: theArray is an array of size items; + // size >= 1. + // Postcondition: Returns the index of the largest + // item in the array. + private static int indexOfLargest(Comparable[] theArray, int size) + { + int indexSoFar = 0; // index of largest item found so far + // Invariant: theArray[indexSoFar]>=theArray[0..currIndex-1] + for (int currIndex = 1; currIndex < size; ++currIndex) + { + if (theArray[currIndex].compareTo(theArray[indexSoFar])>0) + { + indexSoFar = currIndex; + } // end if + } // end for + + return indexSoFar; // index of largest item + } // end indexOfLargest + + // Sorts the items in an array into ascending order. + // Precondition: theArray is an array of n items. + // Postcondition: theArray is sorted into + // ascending order. + // Calls: indexOfLargest. + public static void selectionSort(Comparable[] theArray, int n) + { + // last = index of the last item in the subarray of + // items yet to be sorted + // largest = index of the largest item found + + Comparable temp; + + for (int last = n-1; last >= 1; last--) //all but + { + // Invariant: theArray[last+1..n-1] is sorted + // and > theArray[0..last] + + // select largest item in theArray[0..last] + int largest = indexOfLargest(theArray, last+1); + + // swap largest item theArray[largest] with + // theArray[last] + temp = theArray[largest]; + theArray[largest] = theArray[last]; + theArray[last] = temp; + } // end for + + } // end selectionSort + + // Sorts the items in an array into ascending order. + // Precondition: theArray is an array of n items. + // Postcondition: theArray is sorted into ascending + // order. + public static void insertionSort(Comparable[] theArray, int n) + { + // unsorted = first index of the unsorted region, + // loc = index of insertion in the sorted region, + // nextItem = next item in the unsorted region + + // initially, sorted region is theArray[0], + // unsorted region is theArray[1..n-1]; + for (int unsorted = 1; unsorted < n; ++unsorted) + { + // Invariant: theArray[0..unsorted-1] is sorted + + // find the right position (loc) in + // theArray[0..unsorted] for theArray[unsorted], + // which is the first item in the unsorted + // region; shift, if necessary, to make room + Comparable nextItem = theArray[unsorted]; + int loc = unsorted; + + while ((loc > 0) && (theArray[loc-1].compareTo(nextItem) > 0)) + { + // shift theArray[loc-1] to the right + theArray[loc] = theArray[loc-1]; + loc--; + } // end while + // insert nextItem into sorted region + theArray[loc] = nextItem; + } // end for + + } // end insertionSort + + // Sorts the items in an array into ascending order. + // Precondition: theArray is an array of n items. + // Postcondition: theArray is sorted into ascending + // order. + public static void bubbleSort(Comparable[] theArray, int n) + { + boolean sorted = false; // false when swaps occur + for (int pass = 1; (pass < n) && !sorted; ++pass) + { + // Invariant: theArray[n+1-pass..n-1] is sorted + // and > theArray[0..n-pass] + sorted = true; // assume sorted + for (int index = 0; index < n-pass; ++index) + { + // Invariant: theArray[0..index-1] <= theArray[index] + int nextIndex = index + 1; + if (theArray[index].compareTo(theArray[nextIndex]) > 0) + { + // exchange items + Comparable temp = theArray[index]; + theArray[index] = theArray[nextIndex]; + theArray[nextIndex] = temp; + sorted = false; // signal exchange + } // end if + } // end for + + // Assertion: theArray[0..n-pass-1] < theArray[n-pass] + } // end for + + } // end bubbleSort + + // Merges two sorted array segments theArray[first..mid] and + // theArray[mid+1..last] into one sorted array. + // Precondition: first <= mid <= last. The subarrays + // theArray[first..mid] and theArray[mid+1..last] are + // each sorted in increasing order. + // Postcondition: theArray[first..last] is sorted. + // Implementation note: This method merges the two + // subarrays into a temporary array and copies the result + // into the original array anArray. + private static void merge(Comparable[] theArray, int first, int mid, int last) + { + int maxSize = theArray.length; + // temporary array + Comparable[] tempArray = new Comparable[maxSize]; + + // initialize the local indexes to indicate the subarrays + int first1 = first; // beginning of first subarray + int last1 = mid; // end of first subarray + int first2 = mid + 1; // beginning of second subarray + int last2 = last; // end of second subarray + // while both subarrays are not empty, copy the + // smaller item into the temporary array + int index = first1; // next available location in + // tempArray + while ((first1 <= last1) && (first2 <= last2)) + { + // Invariant: tempArray[first1..index-1] is in order + if (theArray[first1].compareTo(theArray[first2])<=0) //careful here for stable sorting + { + tempArray[index] = theArray[first1]; + first1++; + } + else + { + tempArray[index] = theArray[first2]; + first2++; + } // end if + + index++; + } // end while + + // finish off the nonempty subarray + + // finish off the first subarray, if necessary + while (first1 <= last1) + { + // Invariant: tempArray[first1..index-1] is in order + tempArray[index] = theArray[first1]; + first1++; + index++; + } // end while + + // finish off the second subarray, if necessary + while (first2 <= last2) + { + // Invariant: tempArray[first1..index-1] is in order + tempArray[index] = theArray[first2]; + first2++; + index++; + } // end while + + // copy the result back into the original array + for (index = first; index <= last; ++index) + { + theArray[index] = tempArray[index]; + } // end for + } // end merge + + // Sorts the items in an array into ascending order. + // Precondition: theArray[first..last] is an array. + // Postcondition: theArray[first..last] is sorted in + // ascending order. + // Calls: merge. + public static void mergeSort(Comparable[] theArray, int first, int last) + { + if (first < last) + { + // sort each half + int mid = (first + last)/2; // index of midpoint + // sort left half theArray[first..mid] + mergeSort(theArray, first, mid); + // sort right half theArray[mid+1..last] + mergeSort(theArray, mid+1, last); + + // merge the two halves + merge(theArray, first, mid, last); + } // end if + } // end mergesort + + // Sorts the items in an array into ascending order. + // Precondition: theArray[first..last] is an array. + // Postcondition: theArray[first..last] is sorted. + // Calls: partition. + public static void quickSort(Comparable[] theArray, int first, int last) + { + int pivotIndex; + + if (first < last) + { + // create the partition: S1, Pivot, S2 + pivotIndex = partition(theArray, first, last); + + // sort regions S1 and S2 + quickSort(theArray, first, pivotIndex-1); + quickSort(theArray, pivotIndex+1, last); + } // end if + } // end quickSort + + // Partitions an array for quicksort. + // Precondition: theArray[first..last] is an array; + // first <= last. + // Postcondition: Returns the index of the pivot element of + // theArray[first..last]. Upon completion of the method, + // this will be the index value lastS1 such that + // S1 = theArray[first..lastS1-1] < pivot + // theArray[lastS1] == pivot + // S2 = theArray[lastS1+1..last] >= pivot + // Calls: choosePivot. + private static int partition(Comparable[] theArray, int first, int last) + { + // tempItem is used to swap elements in the array + Comparable tempItem; + // place pivot in theArray[first] + choosePivot(theArray, first, last); + Comparable pivot = theArray[first]; // reference pivot + + // initially, everything but pivot is in unknown + int lastS1 = first; // index of last item in S1 + + // move one item at a time until unknown region is empty + + for (int firstUnknown = first + 1; firstUnknown <= last; ++firstUnknown) + { + // Invariant: theArray[first+1..lastS1] < pivot + // theArray[lastS1+1..firstUnknown-1] >= pivot + + // move item from unknown to proper region + if (theArray[firstUnknown].compareTo(pivot) < 0) + { + // item from unknown belongs in S1 + ++lastS1; + tempItem = theArray[firstUnknown]; + theArray[firstUnknown] = theArray[lastS1]; + theArray[lastS1] = tempItem; + } // end if + // else item from unknown belongs in S2 + } // end for + + // place pivot in proper position and mark its location + tempItem = theArray[first]; + theArray[first] = theArray[lastS1]; + theArray[lastS1] = tempItem; + return lastS1; + } // end partition + + // Chooses a pivot for quicksort's partition algorithm and + // swaps it with the first item in an array. + // Precondition: theArray[first..last] is an array; + // first <= last. + // Postcondition: theArray[first] is the pivot. + private static void choosePivot(Comparable[] theArray, int first, int last) + { + + // Implementation left as an exercise. + + } // end choosePivot + + public static void shellSort(Comparable[] theArray, int n) + { + int loc; + Comparable nextItem; + for (int h = n/2; h > 0; h = h/2) + { + for (int unsorted = h; unsorted < n; ++unsorted) + { + nextItem = theArray[unsorted]; + loc = unsorted; + while ((loc >= h) && (theArray[loc-h].compareTo(nextItem) > 0) ) + { + theArray[loc] = theArray[loc-h]; + loc = loc - h; + } // end while + theArray[loc] = nextItem; + } // end for unsorted + } // end for h + + } // end shellsort + + + /** + * Sorts an array of Radixable elements radixably.
+ * Preconditions: An array of Radixable objects, an integer of the number of keys to sort by, and an integer of the number of elements to sort.
+ * Postconditions: Returns a new array of the sorted elements.
+ * @author Andrew Coleman
+ * @hidden All your base are belong to us. + */ + public static void radixSort(Radixable[] array, int index, int n) { + /* the maximum size of the bin array */ + /* 26 letters, 10 digits, 1 extraneous character */ + final int MAX_SIZE = 26 + 10 + 1; + /* our array for the sorting bins */ + QueueInterface[] bins = new QueueInterface[MAX_SIZE]; + /* the array to return */ + //Radixable[] result = new Radixable[n]; + /* an array to keep the size of each bin at the end of each iteration */ + int[] binsize = new int[MAX_SIZE]; + for (int i = 0; i < MAX_SIZE; i++) {binsize[i] = 0;bins[i] = new QueueReferenceBased();} + /* Strings are indexed with an offset of +1 */ + //index--; + /* these next two hunks of loopage are basically the same, but this way is a big time saver + instead of dumping the original array into a queue/array, i directly sort it into the bins + here and the elements are not taken out of the bins until i return the result array. + I have tried using one big loop and flags, but i get null for every item when i get done sorting. + Besides, it saves on having to do all that extra logic checks a few hundred thousand times */ + for (int iter = 0; iter < n; iter++) { + /* this is the only line that differs between these two loops, here it comes from the array */ + Radixable data = array[iter]; + /* get an ascii value of the character */ + int bin = (int) data.getRadixChar(index); + /* capital letters converted to lowercase */ + if (bin >= 65 && bin <= 90) + bin += 32; + /* lowercase letters */ + if (bin >= 97 && bin <= 122) + bin -= 86; + /* numbers */ + else if (bin >=48 && bin <= 57) + bin -= 47; + /* non alphanumeric characters */ + else + bin = 0; + bins[bin].enqueue(data); + } + + /* already sorted the first character */ + index--; + /* loop through remaining search keys */ + for (int loop = index; loop >= 0; loop--) { + /* save the size of each bin */ + for (int i = 0; i < MAX_SIZE; i++) {binsize[i] = bins[i].size();} + /* loop through each bin */ + for (int iter = 0; iter < MAX_SIZE; iter++) { + /* loop through the number of items saved in binsize + now you don't have to dump the elements into another queue/array */ + for (int eachbinitem = 0; eachbinitem < binsize[iter]; eachbinitem++) { + /* get data from the bins rather than the array */ + Radixable data = (Radixable) bins[iter].dequeue(); + int bin = (int) data.getRadixChar(loop); + if (bin >= 65 && bin <= 90) + bin += 32; + if (bin >= 97 && bin <= 122) + bin -= 86; + else if (bin >=48 && bin <= 57) + bin -= 47; + else + bin = 0; + bins[bin].enqueue(data); + } + } + } + + /* keeps up with the total number of elements placed in the array (always < n) */ + //int count = 0; + /* loop through each bin */ + //for (int i = 0; i < MAX_SIZE; i++) + /* keep dumping the items inside until it's all gone */ + // while (!bins[i].isEmpty()) { + // result[count] = (Radixable) bins[i].dequeue(); + // count++; + // } + /* bye bye */ + //return result; + /* this is sorting 200,000 strings (made by a random word generator in a Tolkien wordset) in + about 1282 milliseconds by my primitive timing methods and by comparison i made a radixsort + earlier that dumps everything into arrays was coming in at > 1600 milliseconds. + */ + } +} \ No newline at end of file diff --git a/SortTime.java b/SortTime.java new file mode 100644 index 0000000..0a1efde --- /dev/null +++ b/SortTime.java @@ -0,0 +1,143 @@ +import java.util.Random; +import java.awt.*; + +public class SortTime +{ + private static Graph myGraph; + private static Object[] original; + private static Object[] originalSorted; + private Object[] sorted; + private static int MAX; + + public SortTime (int xscale,int yscale, String graphTitle) + { + //create the graph object with the specified x-axis, y-axis, and title + myGraph=new Graph(xscale, yscale, graphTitle); + MAX=2*xscale; + Random rand=new Random(); + + //create an array of CDs that have random titles for sorting + original=new CD[MAX]; + originalSorted=new CD[MAX]; + + for (int y=0;ymyGraph.getX()*2) + stop=myGraph.getX()*2; + + //start over with an unsorted array, but the number of items to sort will increase + for (int i=start; i myGraph.getX()) + myGraph.setX(i + i/10); + if (time > myGraph.getY()) + myGraph.setY(time + time/20); + + //show the updated graph + myGraph.repaint(); + } + + } + + public static void main(String[] args) + { + //set up the graph with the x-range, y-range, and title + SortTime timer=new SortTime(10000,2000,"Sorting Times"); + + //run simulations for various sorting techinques + //starting number to sort, ending number to sort, step size for simulation, title of set of points, color of set of points, sorting algorithm to use (see above) + timer.go(1,1900,100,"Selection",Color.blue,1); + timer.go(1,1900,100,"Insertion",Color.red,2); + timer.go(1,1900,100,"Bubble",Color.yellow,3); + + timer.go(1,5000,100,"Merge",Color.green,4); + timer.go(1,10000,100,"Quick",Color.white,5); + timer.go(1,10000,100,"Radix",Color.gray,6); + } + +} +