From a231da731dce55218da4cbfb3ec4a2ce40b3fa8e Mon Sep 17 00:00:00 2001 From: mercury Date: Wed, 3 Dec 2003 17:41:26 +0000 Subject: [PATCH] Initial revision --- CD.java | 83 ++++++++ Data.java | 31 +++ DataVector.java | 63 ++++++ GenericWindowListener.java | 26 +++ Graph.java | 87 ++++++++ ListArrayBased.java | 131 ++++++++++++ ListException.java | 9 + ListInterface.java | 77 +++++++ ListIterator.java | 54 +++++ Node.java | 30 +++ QueueException.java | 9 + QueueInterface.java | 59 ++++++ QueueReferenceBased.java | 103 ++++++++++ Radixable.java | 12 ++ SortRoutines.java | 401 +++++++++++++++++++++++++++++++++++++ SortTime.java | 143 +++++++++++++ 16 files changed, 1318 insertions(+) create mode 100644 CD.java create mode 100644 Data.java create mode 100644 DataVector.java create mode 100644 GenericWindowListener.java create mode 100644 Graph.java create mode 100644 ListArrayBased.java create mode 100644 ListException.java create mode 100644 ListInterface.java create mode 100644 ListIterator.java create mode 100644 Node.java create mode 100644 QueueException.java create mode 100644 QueueInterface.java create mode 100644 QueueReferenceBased.java create mode 100644 Radixable.java create mode 100644 SortRoutines.java create mode 100644 SortTime.java 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); + } + +} +