Intermediate Programming Programming-Tools and Sorting-Algorithms Exercise Sheet Deadline on 13th of November 2009

Transcription

1 Institute of Scientific Computing Technische Universität Braunschweig Prof. Hermann G. Matthies, Ph. D. Dominik Jürgens Winter Term 2009 August 11, 2009 Intermediate Programming Programming-Tools and Sorting-Algorithms Exercise Sheet Deadline on 13th of November 2009 Exercise 1: First Steps Task a) To understand the targets of this course, please read the first chapter of the introductory text. You can find the text on our web-page under the link Course Material in the English version of the page (click on the union flag at the top). Task b) Read chapter 2 The UNIX Working Environment of the introductory text. Make yourself familiar with the UNIX commands for listing, renaming and deleting files, for creating directories and with the man-system, which is the help environment on UNIX. Important commands which you have to know are: man, ls, cp, mkdir, rm, mv, cd. Task c) Go to the web-page and print out the C Reference Card. It will help you during the course. Task d) Work yourself through chapter 3 of the introductory text. While you read the text type in the programs yourself, so you learn the characters and where they are on the keyboard. These characters are important when programming in C. Task e) Create a program header, which you can later use to introduce your program files. Save the header in a file, so that you can copy it later to paste it in every new program file. The header should look like the example in listing 1. 1 /******************************************************************** 2 * 3 * Pet Patterson, Comp. Sci. in Eng., 2. Sem., Mat-Nr * Tim Templaton, Comp. Sci. in Eng., 1. Sem., Mat-Nr * 6 * * 8 ********************************************************************/ Listing 1: Example-Program Header

2 Note: For each exercise you should create a new folder to store the files for the given task. This will help you to separate solution from each other and to find your solutions again. Exercise 2: Small Changes to a Program In this exercise we consider the program helloworld.c from the introductory text. At this point the program shall be slightly manipulated. For reading in a character string (string for short), memory has to be reserve (see Chapters 5.5 (3 pages) in Textbook [Kernighan,Ritchie:1988] ). This can be done with the line char name[10]; which declares a variable name and reserves memory for nine characters. The maximal length of legal strings, which can be put into name is nine (not ten), because every string in C has to be terminated by a special symbol the \0. This termination symbol is again a symbol and needs memory. In many cases, the compiler automatically terminates strings, but in allocation you have to remember that issue. Reading in a name into the variable name can be done with the line: scanf("%s",&name); Printing name can be done by adding an additional argument of the print function and by adding a place holder to the format string: printf("hallo %s!\n",name); Note: Both functions scanf and printf are formatted I/O (I=Input,O=Output); the f in their names is chosen by that reason. The first parameter of functions of that category is a format string, which defines the format of the in-/output. The formatting symbol %s of the format string defines that the variable which is given after the format string is a string (so a char* in C). An overview of such formatting symbols can be found on the C Reference Card in section Codes for Formatted I/O in the subsection Input/Output. When applying the function scanf, its parameter (here name) has to be passed with a &. This means that not the value of name is passed to the function (in contrast to the call to printf), but a reference to the memory location of name. This is due to the function, which has to change the value of the variable instead of reading it. The & is an important operator in C which gives back the address of the memory location of the variable on its right hand side. The position of the formatting symbols defines, where variables shall appear (output), and where they shall be read (input). If multiple variables are given, their order and count has to be equal to the order and count in the format string. Details concerning this topic can be find in Chapter 7 (15 pages) in Textbook [Kernighan,Ritchie:1988]. Task a) Extend the program helloworld.c from the introductory text in chapter 3 with a personal greeting. For that, the program shall read in a name and print it in the personalised greeting. Use the previously given declarations and function calls. Example for a personalised greeting: Hello Bruce!

3 Task b) Start your program and try to put in a name longer than 9 characters. Note: You can see that the input of a name longer than the reserved memory results in an error, which makes the program crash. The function scanf does not get information on how much memory is reserved for the given variable name. Therefore the function overwrites memory which does not have anything to do with the variable name. Such errors are called Buffer overflows (http: //en.wikipedia.org/wiki/buffer_overflow) and can be exploited by hackers for different kinds of things. You always have to think of what you are doing, especially, if security relevant software has to be developed. The simple example shows how important it is to engineer software systematically. In this example the error can be vanished by telling scanf the length of the allocated memory. This can be done by changing the call to: scanf("%9s",name); Task c) Make this change to your program and try to put in a name longer than 9 characters again. Task d) Extend your program with a loop to support multiple greetings. Think of an criterion to abort, e.g. a special character at the beginning of a name. Loops are explained in Chapters 3.5 and 3.6 (5 pages) in Textbook [Kernighan,Ritchie:1988]. Task e) Use the input redirection from chapter I/O-Redirection in the introductory text, to test your program with a predefined number of names. Exercise 3: Software-Engineering Tools For systematically develop programs, you need to know some software tools. Task a) Work through chapter 5 of the introductory text. The tools which are explained in the chapter have to be used in every future exercise.

4 Note: In a lecture on algorithms you should have learned about sorting-procedures. In the present exercis you will apply and test these algorithms and you will verify their computational complexity. We will use arrays in this task, therefore you shall also read Chapter 5 (28 pages) in Textbook [Kernighan,Ritchie:1988]. We provide a program to generate input data for testing the sorting-algorithms. You can download this program here Compile the program with make sortdata. When you execute it by./sortdata -f 10 you should get an output of the number 10 followed by 10 nearly sorted random numbers. When you execute it by./sortdata testfile a file testfile will be created, which contains the number followed again by nearly sorted random numbers. The program has additional options which you will get when executing./sortdata without arguments. Exercise 4: Sorting Task a) Read Chapter 5.10 (4 pages) in Textbook [Kernighan,Ritchie:1988] and Chapter 7 (15 pages) in Textbook [Kernighan,Ritchie:1988] and recall Chapter 5 (28 pages) in Textbook [Kernighan,Ritchie:1988] and Chapter 4 (21 pages) in Textbook [Kernighan,Ritchie:1988]. Review the code in sortdata.c calmly and try to understand every line. Concentrate on the lines which interpret the command-line arguments. Task b) Load down the files in and try to understand the code.

5 1 #include<stdio.h> 2 /**************************************************/ 3 /* function to write an integer array into a file */ 4 /* args: 1. filepointer to write to */ 5 /* 2. integer array */ 6 /* 3. length of the array */ 7 /**************************************************/ 8 void write(file*, int*, int); 9 /**************************************************/ 10 /* function to read an integer array from file */ 11 /* args: 1. filepointer to read from */ 12 /* 2. pointer to integer array */ 13 /* (has to point to NULL) */ 14 /* 3. pointer to integer will be filled */ 15 /* with the length of the read array */ 16 /* return: 0 on success, -1 on error */ 17 /**************************************************/ 18 int read (FILE*, int**, int*); Listing 2: io.h Note: Important are the functions write and read, which are declared in Listing 2. The implementation in file io.c looks a little bit complicated, but this is caused by the parametrisation. The memory for the array which is to be loaded has to be allocated within the function, because the size of the array is defined inside the file. The functions allow to read and write arrays of Integers in a standardised way. Use the given functions in the solution of the next exercises.

6 Note: Pointer-arithmetic is an important technique in C, with its help you can calculate with pointers. 1 int read(file* fp, int** data, int* n) 2 { for(i=0;i<(*n);i++) // loop over the entries 5 { 6 if(!is_eof(fp)) 7 { 8 fscanf(fp,"%i",(*data)+i); // read entry i 9 } } Listing 3: io.c with Pointer arithmetics The code fragment in listing 3 is taken from the file io.c and shows in line 8 an example for the use of pointer arithmetic. Here (*data) dereferences a pointer to a pointer to integer with the name data; a pointer to pointer becomes a pointer. This pointer points to the first entry of an array, which was allocated by calloc. By adding i, meaning (*data)+i the pointer is incremented by i entries and points therefore to the memory with the address (*data)+i. This address is given to the function fscanf, which saves the read value in this location. In figure 1 on page 10 again a few examples for handling pointers are illustrated. Pointer arithmetic should not be used excessively, but should only be applied, where it is absolutely needed. When sorting arrays you should be familiar with this technique. Task c) Write a program sort which reads in data provided by sortdata, sorts this input and prints out the result to another file. The output file shall have the same format as the files created by sortdata (use the provided function write). Implement the two sorting algorithms Insertion-sort and Quicksort provide command line parameters, with which a certain algorithm can be selected (-i for Insertion-sort and -q for Quicksort). The algorithms are presented on the following pages. Note: You can find more information about the considered algorithms at the following locations: Insertion-sort Quicksort

7 Note: Here we gave a short summary of the algorithms. We thereby follow the book Introduction to Algorithms of T.H.Cormen et al.: Insertion-sort algorithm INSERTION-SORT(A) 1 for j 2 to length[a] 2 do key A[j] 3 //Insert A[j] into the sorted sequence A[1.. j 1]. 4 i j 1 5 while i > 0 and A[i] > key 6 do A[i + 1] A[i] 7 i i 1 8 A[i + 1] key Warning: The pseudocode given in T.H.Cormen et al. assumes arrays to start with index 1 instead of index 0 (which is the case in C). This index-shift is common in many pseudocodes (as in some other programming languages as Fortran). PARTITION(A, p, r) Quicksort algorithm QUICKSORT(A, p, r) 1 if p < r 2 then q PARTITION(A, p, r) 3 QUICKSORT(A, p, q) 4 QUICKSORT(A, q + 1, r) 1 x A[p] 2 i p 1 3 j r while TRUE 5 do repeat j j 1 6 until A[j] x 7 repeat i i until A[i] x 9 if i < j 10 then exchange A[i] A[j] 11 else return j

8 Task d) Implement a program test sorted which reads in the common file format and tests if the given sequence is sorted. Task e) Test your sorting routine with null, one, two, and then with three arbitrary numbers. Task f) Another borderline case is the sorting of a already sorted list. Test your implementation therefore with the numbers 1 to 10 already upwards and downwards sorted and than with a sequence of 10 equal numbers. Task g) Test each of the sorting algorithms with three different data sets produced by sortdata. Exercise 5: Measure Time Task a) Give your sorting program another command line parameter -t, which shall make your program printout the execution-time of a sorting run instead of the result. Only measure the time for sorting without input and output. Note: For measuring time you need a stopwatch. We provide a library to you which implements such a device: After you have extracted the package you should start by testing the library with make test. This call also creates the library libstopwatch.a, which you need to link your program. The usage of the stopwatch is really simple: start timer() starts the stopwatch pause timer() pauses the stopwatch read timer() reads the elapsed time in seconds 1 #include <stopwatch.h> 2 int main(){ 3 start_timer(); 4 printf("already %fs gone!\n",read_timer()); 5 } Listing 4: Stopwatch Usage In listing 4 you can see an example of correct usage. The example is part of the package stopwatch.zip in the sub-directory usage demo. In this directory you can also find a Makefile, which contains the correct compiler and linker parameters for using the library. Task b) Now test the execution time of your sorting routines with the different algorithms and different input sizes.

9 Note: Now you shall create measure sequences for the execution time of your algorithms with different input sizes: Quicksort and Insertion-sort with option -v, with option -r, without option for sortdata. n=100, n=500, n=1000, n=1500, n=2000, n=2500, etc. until execution time gets too long. To perform each mentioned combination in a comfortable and simple way it is recommended to redirect the output of./sortdata into the sorting program:./sortdata -r /sort -q Task c) Create a graphical presentation of your measurements. Discuss the reasons, why the sorting algorithms perform differently with different input sets. Why is Quicksort faster on backwardly sorted data sets compared to unsorted ones? Is the log(n) in O(n log n) visible? Note: A good tool to create graphical representations numerical data is gnuplot. To use it call echo plot \"measure.txt\" gnuplot -persist where the file measure.txt has to have the following format: Listing 5: Example of a data file for gnuplot With the call echo plot \"sequence1\",\"sequence2\" gnuplot -persist you can create one graphical representation of two measured sequences in the same figure. The same proceeding can be used with more than two sequences. If you want to learn more about gnuplot, see Note: When interpreting the measured sequences, you will see, that the time for execution of the algorithms varies with with their input. Therefore the complexity of algorithms can be classified from different view-points. Average performance and worst-case performance are the most used in algorithm analysis. Less widely found is bestcase performance, but it does have uses: for example, where the best cases of individual tasks are known, they can be used to improve the accuracy of an overall worst-case analysis. Computer scientists use probabilistic analysis techniques, especially expected value, to determine expected running times. For further information see average_case There are also sorting algorithms available, which do not depend on the input. These always provide the same performance. An example for such algorithms is merge-sort, which always runs in nlogn steps.

10 Figure 1: The figure illustrates a complex example for working with pointers.