SEARCH SORT TEST

/** required package class namespace */
package searchsort;
;
/** required imports */

import collections.
.LinkedList;
/**
.java - useful methods for searching through arrays and
* Searcher. d lists
* of generic data for a specific item
* @author Mr. Wachs
* @param <T> the generic object used in this class
* @since Feb 9, 2017
* @instructor Mr. Wachs
*/
public class Searcher <T extends Comparable<T>>
{
/** indicates the item being searched for is not found */

public final int NOT_FOUND = -1;
/**
* an implementation of a linear search (sequential search)
* algorithm
m. It will find the first occurance of an item
* in the LinkedList and return the index where it found it, or a
* -1 if not found
* @param item the generic data type to search for in the list
* @param array an array of generic items to search through
* @return the first index found at, or a -1 if not found
*/
public int linearSearch(TT item, T[] array) {
for (int i = 0; i < array.length; i++) {
if (array[i].equals(item)) {
return i;
}
}
return NOT_FOUND;
}
/**
* an implementation of a linear search (sequential search)
* algorithm
* -1 if not found
* @param list the LinkedList to search through
*/
public int linearSearch(T
T item, LinkedList<T> list) {
return recursiveLinearSearch(item, list, 0);
}
/**
* an implementation of a binary search (sequential search)
* algorithm
* -1 if not found
* @param array an array of generic items to search through
*/
public int binarySearch(TT item, T[] array) {
int high = array.length - 1;
int low = 0;
while (low <= high) {
int mid = (high + low) / 2;
if (array[mid].compareTo(item) == 0) return mid;
else if (array[mid].compareTo(item) > 0) high = mid - 1;
else if (array[mid].compareTo(item) < 0) low = mid + 1;
}
return NOT_FOUND;
}
/**
* an implementation of a binary search (sequential search)
* algorithm
* -1 if not found
*/
public int binarySearch(TT item, LinkedList<T> list) {
return recursiveBinarySearch(item,list,0,list.size());
}
/**
* recursive methodd to find
d the first occurance of an item
* in the LinkedList andd return the index where it found
d it, or a
* -1 if not found
* @param i the current index location
*/
private int recursiveLinearSearch(T item, LinkedList<<T> list,
, int i) {
if (i == list.size()) return NOT_FOUND;
else if (item.equals(list.get(i))) return i;
else return recursiveLinearSearch(item,list,i+1);
}
/**
* recursive methodd usedd to find
d the item
m in the list and
d
* return the index of it's location or a -1 if not found
* @param low the lowest index to start from
* @param high the highest index to go to
*/
private int recursiveBinarySearch(T item, LinkedList< <T> list,
,
int low, int high) {
if (low <= high) {
int mid = low + (high - low) / 2;
if (list.get(mid) == null) return NOT_FOUND;
if (list.get(mid).compareTo(item) > 0)
return recursiveBinarySearch(item,list,low,mid-1);
else if (list.get(mid).compareTo(item) < 0)
return recursiveBinarySearch(item,list,mid+1,high);
else
return mid;
}
return NOT_FOUND;
}
}
package searchsort;
;

import collections.
.LinkedList;
/**
.java - useful methods for sorting arrays and
* Sorter. d lists
* @author Mr. Wachs
* @since Feb 9, 2017
*/
public class Sorter <T extends Comparable<T>>
{
/**
* a simple implementation of a bubble sort algorithm
* it will sort the array into ascending order
* @param array the array of generic items to sort
*/
public void bubbleSort(TT[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1; j++) {
T item1 = array[j];
T item2 = array[j+1];
if (item1.compareTo(item2) > 0) {
array[j] = item2;
array[j+1] = item1;
}
}
}
}
/**
* an efficient implementation of a bubble sort algorithm
* it will sort the list into ascending order
* @param list the LinkedList to sort
*/
public void bubbleSort(L
LinkedList<T> list) {
boolean sorted = true;
for (int i = list.size() - 1; i >= 0; i--) {
sorted = true;
for (int j = 0; j < i; j++) {
T item1 = list.get(j);
T item2 = list.get(j+1);
if (item1.compareTo(item2) > 0) {
sorted = false;
list.set(j, item2);
list.set(j+1, item1);
}
}
if (sorted) return;
}
}
/**
* an implementation of a selection sort algorithm
* it will sort the array into ascending order
* @param array the array of generic items to sort
*/
public void selectionSort(T T[] array) {
for (int i = 0; i < array.length-1; i++) {
int lowest = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j].compareTo(array[lowest]) < 0) {
lowest = j;
}
}
if (lowest != i) {
T temp = array[i];
array[i] = array[lowest];
array[lowest] = temp;
}
}
}
/**
* an implementation of a selection sort algorithm
* it will sort the list into ascending order
* @param list the LinkedList to sort
*/
public void selectionSort(LLinkedList<T
T> list)
) {
for (int i = 0; i < list.size()-1; i++) {
int lowest = i;
for (int j = i + 1; j < list.size(); j++) {
T item1 = list.get(j);
T item2 = list.get(lowest);
if (item1.compareTo(item2) < 0) {
lowest = j;
}
}
if (lowest != i) {
T temp1 = list.get(i);
T temp2 = list.get(lowest);
list.set(i, temp2);
list.set(lowest, temp1);
}
}
}
}
package testing.
.searchsort;

import searchsort.
.Searcher;
/**
.java - the testing done on the Searcher class
* SearchTest.
* @author Mr. Wachs
* @since Mar 1, 2017
*/
public class SearchTest
{
/** default constructor for the class */

public SearchTest() {
System.
.out.println("\nSearching Test starting........\n");
bigTest(();
System.
.out.println("\nSearching Test completed........\n");
}
/** the large test on a variety of data types */

private void bigTest() {
Searcher search = new Searcher();
System.
.out.p
println(
("Linear Search Tests...\n");
SearchSortTest.resetListAndArrayData();
System.
.out.p
println(
("The current lists and arrays...\n");
SearchSortTest.outputListAndArrayData());
SearchSortTest.randomSearchItems();
SearchSortTest.locationSearchItems());
int result1 = search.linearSearch(SearchSortTest.item1,
SearchSortTest.list1);
SearchSortTest.array1);
System.
.out.println("\nSearching for random data...\n");
SearchSortTest.results("
"Search 1 of List 1", ,
SearchSortTest.item1, result1);
;
;
;
;
;
"Search 6 of Array 1",,
;
;
;
;
"Search 10 of Array 5",
,
SearchSortTest.item5, result10);;
System.
.out.println("\nSearching for found data...\n");
"Search 11 of List 1",,
SearchSortTest.item10,result15);;
System.
.out.println("\nBinary Search Tests...\n"));
SearchSortTest.sortAllListsAndArrays();
System.
.out.p
println(
("The current lists and arrays...\n");
SearchSortTest.outputListAndArrayData());
SearchSortTest.randomSearchItems();
SearchSortTest.locationSearchItems());
result1 = search.binarySearch(SearchSortTest.item1,
System.
.out.println("\nSearching for random data...\n");
;
;
;
;
;
"Search 26 of Array 1", ,
;
;
;
;
,
System.
.out.println("\nSearching for found data...\n");
SearchSortTest.item10,result15);
;
,
;
,
;
,
;
,
;
,
;
}
}
package testing.
.searchsort;

import searchsort.
.Sorter;
/**
.java - the testing done on the Sorter class
* SortTest.
* @author Mr. Wachs
*/
public class SortTest
{

public SortTest() {
System.
.out.println("\nSorting Test starting........\n");
bigTest(();
System.
.out.println("\nSorting Test completed........\n");
}
/** the large test on a variety of data types */

private void bigTest() {
Sorter sorter = new Sorter();
System.
.out.p
println(
("Reseting Bubble Sorting Data...");
SearchSortTest.outputListAndArrayData();
System.
.out.p
println(
("Bubble Sorting Data...");
sorter.
.bubbleSort(SearchSortTest.array1);
sorter.
sorter.
sorter.
sorter.
sorter.
.bubbleSort(SearchSortTest.list1);
sorter.
sorter.
sorter.
sorter.
SearchSortTest.outputListAndArrayData()
);
System.
.out.p
println(
("Reseting Selection Sorting Data...");
SearchSortTest.outputListAndArrayData()
);
System.
.out.p
println(
("Selection Sorting Data...");
sorter.
.selectionSort(SearchSortTest.array1);
sorter.
sorter.
sorter.
sorter.
sorter.
.selectionSort(SearchSortTest.list1);
sorter.
sorter.
sorter.
sorter.
SearchSortTest.outputListAndArrayData();
}
}
package testing.
.searchsort;

import collections..LinkedList;
import numbers.
.Random;
import searchsort.
.Sorter;
/**
.java - the testing done on both searching and
* SearchSortTest. d sorting, and
* the support methods to do this
* @author Mr. Wachs
*/
public class SearchSortTest <T>
{
/** class constant property */

public static final int SIZE = 10;
/** class data properties */

public static LinkedList<Boolean> list1;
public static LinkedList<Integer> list2;
public static LinkedList<Double> list3;
public static LinkedList<Character> list4;
public static LinkedList<String> list5;
public static Boolean[] array1;
public static Integer[] array2;
public static Double[] array3;
public static Character[] array4;
public static String[] array5;
public static Boolean item1;
public static Integer item2;
public static Double item3;
public static Character item4;
public static String item5;

public SearchSortTest() {
System.
.out.println("\nSearching and Sorting Test starting........\n");
SearchTest searchTest = new SearchTest();
SortTest sortTest = new SortTest();
System.
.out.println("\nSearching and Sorting Test complete........\n");
}
/** resets all lists and arrays to random data */

public static void resetListAndArrayData() {
list1 = new LinkedList<>();
array1 = new Boolean[[SIZE];
array2 = new Integer[[SIZE];
array3 = new Double[
[SIZE];
array4 = new Character[SIZE];
array5 = new String[
[SIZE];
for (int i = 0; i < SIZE; i++) {
item1 = Random.generate();
item2 = Random.generate(0,SIZE-1);
item3 = Random.generate(00d,(double)(
(SIZE-1));
item4 = Random.generate('a','z');
item5 = Random.generate(SIZE);
list1.add(item1);
list2.add(item2);
list3.add(item3);
list4.add(item4);
list5.add(item5);
array1[i] = item1;
array2[i] = item2;
array3[i] = item3;
array4[i] = item4;
array5[i] = item5;
}
}
/** outputs all lists and arrays to the screen */

public static void outputListAndArrayData() {
System.
.out.p
println(
("List 1: " + list1);
System.
.out.p
println(
("List 2: " + list2);
System.
.out.p
println(
("List 3: " + list3);
System.
.out.p
println(
("List 4: " + list4);
System.
.out.p
println(
("List 5: " + list5);
System.
.out.p
println(
("Array 1: " + output(array1));
System.
.out.p
println(
System.
.out.p
println(
System.
.out.p
println(
System.
.out.p
println(
}
/** generates random data to search for in the lists and arrays */
public static void randomSearchItems() {
item1 = Random..generate();
item2 = Random..generate(0,SIZE-1);
item3 = Random..generate(0
0d,,(double)(
(SIZE-1));
item4 = Random..generate('a','z');
item5 = Random..generate(SIZE);
item6 = Random..generate();
item7 = Random..generate(0,SIZE-1);
item8 = Random..generate(0
0d,,(double)(
(SIZE-1));
item9 = Random..generate('a','z');
item10 = Random..generate(SIZE);
}
/** generates search data that is already in the lists and arrays */
public static void locationSearchItems() {
item11 = SearchSortTest.list1.get(R
Random.generate(0, SIZE-1));
Random.generate(0, SIZE-1
1));
item16 = SearchSortTest.array1[Random.generate(0, SIZE-1)];
}
/**
* outputs the search results
* @param text which search results this is
* @param item the item being searched for
* @param location the result of the search
*/
public static <T> void results(S
String text,
, T item,
, int location)
) {
System.
.out.p
println(
(text + "\t result = " + location +
"\t for item " + item.toString());
}
/** sorts all lists and arrays for the binary search */
public static void sortAllListsAndArrays() {
Sorter sorter = new Sorter();
sorter.
sorter.
sorter.
sorter.
sorter.
sorter.
sorter.
sorter.
sorter.
sorter.
}
/**
* outputs the contents of an array on the screen
* @param array the array to output
* @return the nicely formatted output of the array
*/
private static <T> String output(TT[] array)) {
String text = "[";
for (int i = 0; i < array.length-1; i++) {
text += array[i].toString() + ",";
}
return text + array[array.length-1].toString() + "]";
}

SEARCH SORT TEST

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SEARCH SORT TEST

Uploaded by

Copyright:

Available Formats

/** required package class namespace */

/** required imports */

/** indicates the item being searched for is not found */

/** required imports */

/** required imports */

/** default constructor for the class */

/** the large test on a variety of data types */

/** required imports */

/** default constructor for the class */

/** the large test on a variety of data types */

/** required imports */

/** class constant property */

/** class data properties */

/** default constructor for the class */

/** resets all lists and arrays to random data */

/** outputs all lists and arrays to the screen */

You might also like