All the algorythms are written in C. The algorythms could have been implemented
in any other language with the same or atleast similar results. To my unders-
tanding C++ might only take a bit longer to lead but down to the basic opera-
tion it should not make that big of a difference in the execution time. I 
have coded the algorithms as requested by looking at the slides and translating
in to high level programming language.
The input data is generated as the seed for the random number generating system
function is the process id for the current process. Process ids are unique for
each process so every time the program is sun it genereates different set of
random elements. The size of part before the decimal varies from 0 to RAND_MAX 
(over 2,000,000,000) after this another random number is generated and devided 
apropriately to append the numbers after the decimal. I did this in order to create a list of unique elements in which no 2 are the same. Mainly this was needed
for the searching algorithms.
I used gettimeofday() function to time the algorythms. For the sequential
search algorithm this function had to be inserted immediatly befor the search
begins and immediately after the search is completed. The reason for this is 
other possible overhead that could result in false timing. For the binary
search the gettimeofday() function was inserted after the elements were sorted using qsort() system call. I did this because of the nature of binary search  -
it searches through sorted array of elements. Similarly to the sequential
search, the bubble sort algorythm also got prefixed and appended with 
gettimeofday(). 
The only function that may seem unusual because was not specified in the 
handout was the one included in the binary search code. It has the purpose to 
determine the comparison method for the qsort() function (required by format).
The tests were performed on 1.8 GHz Pentium 4, 256 MB RAM, Red Hat Linux 9.0,
with nothing but kernel, logger, cron, and tty deamons running. The executables
were run at the console one after another after initial rebooting before the 
test begun. The code for each algorythm finalizes its execution with displaying the appropriate elements that are relevant to its nature (searched element, 
key position where expected to be found, element found, and its position,
execution time). Elements other than the total execution time were included 
only for testing purposes. 
Every experiment was run with: `./a.out > name.size.yes/no`
name - name of algorithm
size - input size
yes/no - only relevant to searching algorythms, if element searched for 
	is present in the list or not. 
Since the list only contains positive numbers then required .5 probability was
accomplished by searching for a negative element half of the time (3 out of 6)