Search Techniques and Hashing Solution

iLAB OVERVIEW

Scenario and Summary

The purpose of the lab exercises is to help the student acquire skills in developing programs that involve search algorithms and techniques.

Deliverables

There are four exercises in this lab, although not all of them will be required for submission. Be sure to read the following instructions carefully.

Exercise 1: No submission is required.

Note that one of the exercises requires sections of code to be timed. To review how to time a section of your source code, please refer to the beginning of the Projects section in Chapter 4 of our textbook.



Exercise 2 requires not only software development but also explanations about the results of the experiments that are conducted. Create a separate Word document to provide the details required in the exercise.

Create a folder and name it Week 5 Lab. Inside this folder, create the subfolders Ex2, Ex3, and Ex4. Place the solution to each of the three exercises required for submission in the corresponding subfolder. Compress the folder Week 5 Lab, and place the resulting zipped folder into the Dropbox.

Note that Exercises 2, 3, and 4 require software development. Place in the corresponding folders only .java files. Do not submit the .class files or other files or folders that are generated by the IDE.

Required Software

Eclipse

Access the software at https://lab.devry.edu .

iLAB STEPS

Exercise 1: Review of the Lecture Content

Back to Top

Create a project using the ArrayList class and the Main class in Search Algorithms. The ArrayList class contains implementations of the first three search methods explained in this week’s lecture: sequential, sorted, and binary search. The Main class uses these three methods. These programs test the code discussed in the lecture. Compile the project, run it, and review the code that is given carefully.

Code :

Main:

/*******************************************

* Week 5 lab - exercise 1 and exercise 2: *

* ArrayList class with search algorithms *

********************************************/



import java.util.*;



/**

* Class to test sequential search, sorted search, and binary search algorithms

* implemented in ArrayList.

*/

public class Main

{



public static void main(String[] args)

{

Main myAppl = new Main();

}



public Main()

{

Scanner in = new Scanner(System.in);



//List creation and display

int n = 20;

ArrayList numbers = new ArrayList(n);



for (int i = 0; i < n; i++)

numbers.add((int) (Math.random() * 100));



System.out.println("List of integers:");

System.out.println(numbers);



//Searching with sequential search

System.out.print("\n(Sequential Search) Enter a number:");

int x = in.nextInt();

if (numbers.sequentialSearch(x))

System.out.println("Found!");

else

System.out.println("Not found!");



//Sorting the list

numbers.quicksort();

System.out.println("\nSorted list of integers:");

System.out.println(numbers);



//Searching with sorted search

System.out.print("\n(Sorted Search) Enter a number:");

x = in.nextInt();

if (numbers.sortedSearch(x))

System.out.println("Found!");

else

System.out.println("Not found!");



//Searching with binary search

System.out.print("\n(Binary Search) Enter a number:");

x = in.nextInt();

if (numbers.binarySearch(x))

System.out.println("Found!");

else

System.out.println("Not found!");

}

}


Array List:

/*******************************************

* Week 5 lab - exercise 1 and exercise 2: *

* ArrayList class with search algorithms *

********************************************/



/**

* Class implementing an array based list. Sequential search, sorted search, and

* binary search algorithms are implemented also.

*/

public class ArrayList

{



/**

* Default constructor. Sets length to 0, initializing the list as an empty

* list. Default size of array is 20.

*/

public ArrayList()

{

SIZE = 20;

list = new int[SIZE];

length = 0;

}



/**

* Determines whether the list is empty

*

* @return true if the list is empty, false otherwise

*/

public boolean isEmpty()

{

return length == 0;

}



/**

* Prints the list elements.

*/

public void display()

{

for (int i = 0; i < length; i++)

System.out.print(list[i] + " ");



System.out.println();

}



/**

* Adds the element x to the end of the list. List length is increased by 1.

*

* @param x element to be added to the list

*/

public void add(int x)

{

if (length == SIZE)

System.out.println("Insertion Error: list is full");

else

{

list[length] = x;

length++;

}

}



/**

* Removes the element at the given location from the list. List length is

* decreased by 1.

*

* @param pos location of the item to be removed

*/

public void removeAt(int pos)

{

for (int i = pos; i < length - 1; i++)

list[i] = list[i + 1];

length--;

}



//Implementation of methods in the lab exercise

/**

* Non default constructor. Sets length to 0, initializing the list as an

* empty list. Size of array is passed as a parameter.

*

* @param size size of the array list

*/

public ArrayList(int size)

{

SIZE = size;

list = new int[SIZE];

length = 0;

}



/**

* Returns the number of items in the list (accessor method).

*

* @return the number of items in the list.

*/

public int getLength()

{

return length;

}



/**

* Returns the size of the list (accessor method).

*

* @return the size of the array

*/

public int getSize()

{

return SIZE;

}



/**

* Removes all of the items from the list. After this operation, the length

* of the list is zero.

*/

public void clear()

{

length = 0;

}



/**

* Replaces the item in the list at the position specified by location.

*

* @param location location of the element to be replaced

* @param item value that will replace the value at location

*/

public void replace(int location, int item)

{

if (location < 0 || location = length)

System.out.println("Error: invalid location");

else

list[location] = item;

}



/**

* Adds an item to the list at the position specified by location.

*

* @param location location where item will be added.

* @param item item to be added to the list.

*/

public void add(int location, int item)

{

if (location < 0 || location = length)

System.out.println("Error: invalid position");

else if (length == SIZE)

System.out.println("Error: Array is full");

else

{

for (int i = length; i location; i--)

list[ i] = list[ i - 1];

list[location] = item;

length++;

}

}



/**

* Deletes an item from the list. All occurrences of item in the list will

* be removed.

*

* @param item element to be removed.

*/

public void remove(int item)

{

for (int i = 0; i < length; i++)

if (list[i] == item)

{

removeAt(i);

i--; //onsecutive values won't be all removed; that's why i-- is here

}

}



/**

* Returns the element at location

*

* @param location position in the list of the item to be returned

* @return element at location

*/

public int get(int location)

{

int x = -1;



if (location < 0 || location = length)

System.out.println("Error: invalid location");

else

x = list[location];



return x;

}



/**

* Makes a deep copy to another ArrayList object.

*

* @return Copy of this ArrayList

*/

public ArrayList copy()

{

ArrayList newList = new ArrayList(this.SIZE);



newList.length = this.length;



for (int i = 0; i < length; i++)

newList.list[i] = this.list[i];



return newList;

}



/**

* Bubble-sorts this ArrayList

*/

public void bubbleSort()

{

for (int i = 0; i < length - 1; i++)

for (int j = 0; j < length - i - 1; j++)

if (list[j] list[j + 1])

{

//swap list[j] and list[j+1]

int temp = list[j];

list[j] = list[j + 1];

list[j + 1] = temp;

}

}



/**

* Quick-sorts this ArrayList.

*/

public void quicksort()

{

quicksort(0, length - 1);

}



/**

* Recursive quicksort algorithm.

*

* @param begin initial index of sublist to be quick-sorted.

* @param end last index of sublist to be quick-sorted.

*/

private void quicksort(int begin, int end)

{

int temp;

int pivot = findPivotLocation(begin, end);



// swap list[pivot] and list[end]

temp = list[pivot];

list[pivot] = list[end];

list[end] = temp;



pivot = end;



int i = begin,

j = end - 1;



boolean iterationCompleted = false;

while (!iterationCompleted)

{

while (list[i] < list[pivot])

i++;

while ((j = 0) && (list[pivot] < list[j]))

j--;



if (i < j)

{

//swap list[i] and list[j]

temp = list[i];

list[i] = list[j];

list[j] = temp;



i++;

j--;

} else

iterationCompleted = true;

}



//swap list[i] and list[pivot]

temp = list[i];

list[i] = list[pivot];

list[pivot] = temp;



if (begin < i - 1)

quicksort(begin, i - 1);

if (i + 1 < end)

quicksort(i + 1, end);

}



/*

* Computes the pivot location.

*/

private int findPivotLocation(int b, int e)

{

return (b + e) / 2;

}



/*The methods listed below are new additions to the ArrayList class

* of Week 4*/

/**

* This method returns a string representation of the array list elements.

* Classes with this method implemented can get its objects displayed in a

* simple way using System.out.println. For example, if list is an ArrayList

* object, it can be printed by using

*

* System.out.println(list);

*

* @return a string representation of the array list elements.

*/

public String toString()

{

String s = "";



for (int i = 0; i < length; i++)

s += list[i] + " ";



return s;

}



/**

* Determines if an item exists in the array list using sequential (linear)

* search.

*

* @param x item to be found.

* @return true if x is found in the list, false otherwise.

*/

public boolean sequentialSearch(int x)

{

for (int i = 0; i < length; i++)

if (list[i] == x)

return true;



return false;

}



/**

* Determines if an item exists in the array list using sorted search. List

* must be sorted.

*

* @param x item to be found.

* @return true if x is found in the list, false otherwise.

*/

public boolean sortedSearch(int x)

{

//The list must ne sorted to invoke this method!

int i = 0;

while (i < length && list[i] < x)

i++;



if (i < length && list[i] == x)

return true; // x is in the array

else

return false; // x is not in the array

}



/**

* Determines if an item exists in the array list using binary search. List

* must be sorted.

*

* @param x item to be found.

* @return true if x is found in the list, false otherwise.

*/

public boolean binarySearch(int x)

{

int first = 0, last = length - 1, pivot;



boolean found = false;

while (first <= last && !found)

{

pivot = (first + last) / 2;

if (list[pivot] == x)

found = true;

else if (x < list[pivot])

last = pivot - 1;

else

first = pivot + 1;

}



if (found)

return true;

else

return false;

}

private static int SIZE; //size of the array that stores the list items

private int[] list; //array to store the list items

private int length; //amount of items in the list

}





Exercise 2: Search Algorithms and Techniques

Back to Top

Expand the project developed in the previous exercise to perform the following experiment: Time the sequential search and the binary search methods several times each for randomly generated values, and record the results in a table. Do not time individual searches, but groups of them. For example, time 100 searches together or 1,000 searches together. Compare the running times of these two search methods that are obtained during the experiment.

Regarding the efficiency of both search methods, what conclusion can be reached from this experiment? Both the table and your conclusions should be included in a separate Word document.

Exercise 3: Searching Applications

Back to Top

The following problem is a variation of Project 4 in the "Projects" section of Chapter 18 in our textbook:

Consider an array data of n numerical values in sorted order and a list of two numerical target values. Your goal is to compute the smallest range of array indices that contains both of the target values. If a target value is smaller than data[0], the range should start with a -1. If a target value is larger than data[n-1], the range should end with n.

For example, given the array

0
1
2
3
4
5
6
7
5
8
10
13
15
20
22
26
the following table illustrates target values and their corresponding ranges:

Target Values
Smellest Range of Indices
2, 8
[-1, 1]
9, 14
[1, 4]
12, 21
[2, 6]
14, 30
[3, 8]
Devise and implement an algorithm that solves this problem.

Exercise 4: Hashing

Back to Top

Suppose that the type of key in a hashing application you are implementing is string (Sections 21.7 and 21.8 in our textbook explain hash functions for strings). Design and implement a hash function that converts a key to a hash value. Test your function by computing the hash values for the Java keywords. Was a key collision produced?
Powered by