Professional Documents
Culture Documents
Basic Introduction Into Algorithms and Data Structures (Inglés) Autor Frauke Liers
Basic Introduction Into Algorithms and Data Structures (Inglés) Autor Frauke Liers
Frauke Liers
Computer Science Department
University of Cologne
D-50969 Cologne
Germany
Abstract. This chapter gives a brief introduction into basic data structures and
algorithms, together with references to tutorials available in the literature. We first
introduce fundamental notation and algorithmic concepts. We then explain several
sorting algorithms and give small examples. As fundamental data structures, we in-
troduce linked lists, trees and graphs. Implementations are given in the programming
language C.
Contents
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.1 Insertion Sort . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Some Basic Notation and Analysis of Insertion Sort . . . 4
2.2 Sorting using the Divide-and-Conquer Principle . . . . . . . 7
2.2.1 Merge Sort . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.2 Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 A Lower Bound on the Performance of Sorting Algorithms 12
3 Select the k-th smallest element . . . . . . . . . . . . . . . 12
4 Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5 Elementary Data Structures . . . . . . . . . . . . . . . . . 14
5.1 Stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1
Algorithms and Data Structures (Liers)
1 Introduction
This chapter is meant as a basic introduction into elementary algorithmic principles
and data structures used in computer science. In the latter field, the focus is on
processing information in a systematic and often automatized way. One goal in the
design of solution methods (algorithms) is about making efficient use of hardware
resources such as computing time and memory. It is true that hardware develop-
ment is very fast; the processors’ speed increases rapidly. Furthermore, memory has
become cheap. One could therefore ask why it is still necessary to study how these
resources can be used efficiently. The answer is simple: Despite this rapid develop-
ment, computer speed and memory are still limited. Due to the fact that the increase
in available data is even more rapid than the hardware development and for some
complex applications, we need to make efficient use of the resources.
In this introductory chapter about algorithms and data structures, we cannot cover
more than some elementary principles of algorithms and some of the relevant data
structures. This chapter cannot replace a self-study of one of the famous textbooks
that are especially written as tutorials for beginners in this field. Many very well-
written tutorials exist. Here, we only want to mention a few of them specifically.
The excellent book ‘Introduction to Algorithms’ [5] covers in detail the foundations
of algorithms and data structures. One should also look into the famous textbook
‘The art of computer programming, Volume 3: Sorting and Searching’[7] written by
Donald Knuth and into ‘Algorithms in C’[8]. We warmly recommend these and other
textbooks to the reader.
First, of course, we need to explain what an algorithm is. Loosely and not very
formally speaking, an algorithm is a method that performs a finite list of instructions
that are well-defined. A program is a specific formulation of an abstract algorithm.
Usually, it is written in a programming language and uses certain data structures.
Usually, it takes a certain specification of the problem as input and runs an algorithm
for determining a solution.
2 Sorting
Sorting is a fundamental task that needs to be performed as subroutine in many
computer programs. Sorting also serves as an introductory problem that computer
science students usually study in their first year. As input, we are given a sequence
of n natural numbers ha1 , a2 , . . . , an i that are not necessarily all pairwise different.
As an output, we want to receive a permutation (reordering) ha′1 , a′2 , . . . , a′n i of the
2
2 Sorting
numbers such that a′1 ≤ a′2 ≤ . . . ≤ a′n . In principle, there are n! many permutations
of n elements. Of course, this number grows quickly already for small values of n such
that we need effective methods that can quickly determine a sorted sequence. Some
methods will be introduced in the following. In general, all input that is necessary for
the method to determine a solution is called an instance. In our case, it is a specific
series of numbers that needs to be sorted. For example, suppose we want to sort
the instance h9, 2, 4, 11, 5i. The latter is given as input to a sorting algorithm. The
output is h2, 4, 5, 9, 11i. An algorithm is called correct if it stops (terminates) for all
instances with a correct solution. Then the algorithm solves the problem. Depending
on the application, different algorithms are suited best. For example, the choice of
sorting algorithm depends on the size of the instance, whether the instance is partially
sorted, whether the whole sequence can be stored in main memory, and so on.
1#include <stdio.h>
2#include <stdlib.h>
3void insertion_sort();
3
Algorithms and Data Structures (Liers)
4 main()
5 {
6 int i, j, n;
7 int *A;
8 scanf("%d",&n);
9 A = (int *) malloc((n+1)*sizeof(int));
10 for (i = 1; i <= n; i++) {
11 scanf("%d",&j);
12 A[i] = j;
13 }
14 insertion_sort(A,n);
15 for (i = 1; i <= n; i++) printf("%5d",A[i]);
16 printf("\n");
17}
4
2 Sorting
such arithmetic and logical operations. We assume that such basic operations all need
the same constant time.
5 2 3 6 1 4
2 5 3 6 1 4
2 3 5 6 1 4
2 3 5 6 1 4
1 2 3 5 6 4
1 2 3 4 5 6
Intuitively, sorting 100 numbers takes longer than only 10 numbers. Therefore,
the running time is given as a function of the size of the input (n here). Furthermore,
for sequences of equal length, sorting ‘almost sorted’ sequences should be faster than
‘unsorted’ ones. Often, the so-called worst case running time of an algorithm is
studied as a function of the size of the input. The worst-case running time is the
largest possible running times for an instance of a certain size and yields an upper
bound for the running time of an arbitrary instance of the same size. It is not clear
beforehand whether the ‘worst case’ appears ‘often’ in practice or only represents some
‘unrealistic’, artificially constructed situation. For some applications, the worst case
appears regularly, for example when searching for a non-existing entry in a database.
For some algorithms, it is also possible to analyze the average case running time
which is the average over the time for all instances of the same size. Some algorithms
have a considerably better performance in the average than in the worst case, some
others do not. Often, however, it is difficult to answer the question what an ‘average
instance’ should be, and worst-case analyses are easier to perform. We now examine
the question whether the worst-case running time of insertion sort grows linearly,
or quadratically, or maybe even exponentially in n. First, suppose we are given a
sequence of n numbers, what constitutes the worst case for insertion sort? Clearly,
most work needs to be done when the instance is sorted, but in decreasing instead of
in increasing order. In this case, in each iteration the condition A[i] > key is always
satisfied and the while-loop only stops because the value of i drops to zero. Therefore,
for j = 2 one assignment A[i + 1] = A[i] has to be performed. For j = 3, two of these
assignments have to be done, and so on, until for j = n − 1 we have to perform n − 2
5
Algorithms and Data Structures (Liers)
c1g(x)
f (x)
c2g(x)
n0
In Figure 2, we show the characteristic behavior of two functions for which there
exists constants c1 , c2 such that f (x) = Θ(g(x)).
In principle, one has to take into account that the O-notation can hide large
constants and terms of second order. Although it is true that the leading term de-
termines the asymptotic behavior, it is possible that in practice an algorithm with
1 BTW: What kind of instance constitutes the best case for insertion sort?
6
2 Sorting
slightly larger asymptotic running time performs better than another algorithm with
better O-behavior.
It turns out that also the average-case running time of insertion sort is O(n2 ).
We will see later that sorting algorithms with worst-case running time bounded by
O(n log n) exists. For large instances, they show better performance than insertion
sort. However, insertion sort can easily be implemented and for small instances is
very fast in practice.
In the following, the merge of two sequences A[p],. . .,A[q] and A[q+1],...,A[r]
is implemented. To this end, an additional array B is allocated in which the merged
sequence is stored. Denote by ai and aj the currently considered elements of each of
7
Algorithms and Data Structures (Liers)
the sequences that need to be merged in a zip-fastener manner. Always the smaller
of ai and aj is stored into B (lines 12 and 17). If an element from a subsequence is
inserted into B, its subsequent element is copied into ai (aj, resp.) (lines 14 and 19).
The merged sequence B is finally copied into array A in line 22.
1 void merge(int* A, int p, int q, int r)
2 {
3 int i, j, k, ai, aj;
4 int *B;
5 B = (int *) malloc((r - p + 2)*sizeof(int));
6 i = p;
7 j = q + 1;
8 ai = A[i];
9 aj = A[j];
10 for (k = 1; k <= r - p + 1; k++) {
11 if (ai < aj) {
12 B[k] = ai;
13 i++;
14 if (i <= q) ai = A[i]; else ai = infinity;
15 }
16 else {
17 B[k] = aj;
18 j++;
19 if (j <= r) aj = A[j]; else aj = infinity;
20 }
21 }
22 for (k = p; k <= r; k++) A[k] = B[k-p+1];
23 free(B);
24}
Mergesort is well suited for sorting massive amounts of data that do not fit into
main memory. Subsequences that do fit into main memory are sorted first and then
merged only in the end. It is therefore called an external sorting algorithm.
Without going into a high level of detail, let us analyze the worst-case running
time of merge sort. Suppose it is some function T (n). For ease of presentation, we
assume that n is a power of two, i.e., there exists r ∈ N such that n = 2r . We note
that the middle of the subsequence can be determined in constant time. We then
need to sort two subsequences of size n2 which takes time 2T ( n2 ). Due to the for-loop
in merge(), merging two subsequences of lengths n2 takes time Θ(n). In total, the
function T (n) to be determined needs to satisfy the recurrence
(
Θ(1), for n = 1
T (n) = n
2T 2 + Θ(n), for n > 1
It can be shown that the recurrence is solved by T (n) = Θ(n log2 n). (As a test, in-
sert this function into the recurrence...) Thus, the worst-case running time O(n log n)
of merge sort is better than the quadratic worst-case running time of insertion sort.
8
2 Sorting
1 7 9 2 4 8 3 5
1 7 9 2 4 8 3 5
1 7 9 2 4 8 3 5
1 7 9 2 4 8 3 5
1 7 2 9 4 8 3 5
1 2 7 9 3 4 5 8
1 2 3 4 5 7 8 9
Instead of sorting numbers only, we can easily extend whatever we have said until
now to more general sorting tasks in which we are given n data records s1 , s2 , . . . , sn
with keys k1 , k2 , . . . , kn . An ordering relation ‘≤’ is defined on the keys and we need
to find a permutation of the data such that the permuted data is sorted according
to the ordering relation, as we discuss next. For example, a record could consist of a
name of a person together with a telephone number. The task could be to sort the
records alphabetically. The keys are the people’s names, and the alphabetical order
is the ordering relation.
2.2.2 Quicksort
Quicksort is another divide-and-conquer sorting algorithm that is widely used in prac-
tice. For a sequence with length at most one, nothing is done. Otherwise, we take a
9
Algorithms and Data Structures (Liers)
specific element ai from the sequence, the so-called pivot element. Let us postpone for
the moment a discussion how such a pivot should be chosen. We aim at finding the
correct position for ai . To this end, we start from the left and search for an element
ak in the subsequence left of ai that is larger than ai . As we want to sort in increasing
order, the position of ak is wrong. Similarly, we start from the right and search for an
element al in the subsequence right of ai that is smaller than ai . Elements al and ak
then exchange their positions. If only one such element is found, it is exchanged with
ai . This is the only case in which ai may change its position. Note that ai will still be
the pivot. This procedure is continued until no further elements need to be exchanged.
Then ai is at the correct position, say t, because all elements in the subsequence to its
left are not larger and all elements in the subsequence to its right are not smaller than
ai . This is the division step. We are now left with the task of sorting two sequences
of lengths t − 1 and n − t. Quicksort is called recursively for these sequences (conquer
step). Finally, the subsequences are combined to a sorted sequence by simple concate-
nation. Obviously, the running time of quicksort depends on the choice of the pivot
element. If we are lucky, it is chosen such that the lengths of the subsequences are
always roughly half of the length of the currently considered sequence which means
that we are done after roughly log n division steps. In each step, we have to do Θ(n)
many comparisons. Therefore, the best-case running time of quicksort is Θ(n log n).
If we are unlucky, ai is always the smallest or always the largest element so that we
Pn
need linearly many division steps. Then, we need i=1 i = n(n+1) 2 = Θ(n2 ) many
comparisons which leads to quadratic running time in the worst case. It can be proven
that the average-case running time is bounded from above by O(n log n). Different
choices for the pivot have been suggested in the literature. For example, one can just
always use the ‘rightmost’ element. A C-implementation of quicksort with this choice
of the pivot element is given below. However, quicksort has quadratic running time
in the worst case. Despite the fact that the worst-case running time of quicksort is
worse than that of merge sort, it is still the sorting algorithm that is mostly used in
practice. One reason is that the worst case does not occur often so that the ‘typical’
running time is better than quadratic in n. In practice, merge sort is usually faster
than quicksort.
In the following C-implementation we slightly extend the task to sorting elements
that have a key and some information info. Sorting takes place with respect to key.
A struct item is defined accordingly. In the main routine, we read in the keys for
item A (for brevity, info values are not considered in this example implementation).
Initially, quick sort is called for A and positions 1 to n.
1#include <stdio.h>
2#include <stdlib.h>
3typedef int infotype;
4typedef struct{
5 int key;
6 infotype info;
7} item;
10
2 Sorting
9main()
10{
11 int i,j,n;
12 item *A;
13 scanf("%d",&n);
14 A = (item *) malloc((n+1)*sizeof(item));
15 for (i=1; i<=n; i++) {
16 scanf("%d",&j);
17 A[i].key = j;
18 }
19 A[0].key = -1;
20 quick_sort(A,1,n);
21 for (i=1; i<=n; i++) printf("%5d",A[i].key);
22 printf("\n");
23 free(A);
24}
Next, the implementation of function quick sort is given. In line 8, the pivot
element is taken as the rightmost element at position r. While we find elements that
need to be exchanged with the pivot element (line 9), we compare the pivot with
the elements in the sequence. In line 10, we start with i = l and increase i until
the element at position i is at least as large as the pivot and thus should exchange
position with another element. Similarly, we start in line 11 with j = r and decrease
j until the element at position j is at most as large as the pivot. If position i is left
of j, the corresponding elements exchange position (lines 12–14). Otherwise, only
one element was found that has to be exchanged with the pivot (lines 18–20). The
while-loop stops when no further elements need to be exchanged and thus the pivot is
at the correct position. Then, quick sort is called recursively for the subsequences
A[l],. . ., A[i-1] and A[i+1],. . ., A[r] in lines 21 and 22.
1void quick_sort(item* A, int l, int r)
2{
3 int i,j,pivot;
4 item t;
5 if (r>l) {
6 i = l - 1;
7 j = r;
8 pivot = A[r].key; /* pivot element */
9 while (1) {
10 do i++; while (A[i].key < pivot);
11 do j--; while (A[j].key > pivot);
12 if(i >= j) break; /* i is position of pivot */
13 t = A[i];
14 A[i] = A[j];
15 A[j] = t;
16 }
17 t = A[i];
18 A[i] = A[r];
11
Algorithms and Data Structures (Liers)
19 A[r] = t;
20 quick_sort(A,l,i-1);
21 quick_sort(A,i+1,r);
22 }
}
23
12
4 Binary Search
The resulting ‘median of medians’ is taken as pivot element with the same role as
in quicksort. The sequence is then divided into two subsequences according to the
position of the pivot. The search is continued recursively in the correct subsequence
of the two until the position of the pivot is k and the algorithm stops. It can be
proven that the worst-case running time of this algorithm is bounded by O(n).
4 Binary Search
Suppose we have some sorted sequence at hand and want to know the position of an
element with a certain key k. For example, let the keys be h1, 3, 3, 7, 9, 15, 27i. Suppose
we want to determine the position of an element with key 9. A straightforward linear-
time search algorithm would scan each element in the sequence, compare it with the
element we search for and stops when either the element we look for has been found
or the whole sequence has been scanned without success. If we however know that
the sequence is sorted, searching for a specific element can be done more efficently
with the divide and conquer principle.
Suppose, for example, we want to find the telephone number of a specific person
in a telephone book. Usually, people do a mixture of a divide and conquer method
together with a linear search. In fact, if we look for a person with name Knuth, we
will open the telephone book somewhere in the middle. If the names of the people
where we opened start, say, with an O instead a K, we know we need to search for
Knuth further towards the beginning of the boook. If instead they start with, say,
an F, we need to search further towards the end. If we find that at the beginning of
the current page, the names are ‘close’ to Knuth, we probably continue with a linear
search until we find Knuth.
A more formalized search algorithm using divide and conquer, binary search, needs
only time O(log n) in the worst case. We just compare k with the key of the element
in the middle of the currently considered sorted sequence. If this key is the one we are
searching for, we stop. Otherwise, if the key is smaller than k, we know we have to
search in the subsequence ‘left of the middle’ that contains the elements with smaller
keys. If instead it is larger, the element we look for is in the subsequence right of the
middle. We apply the same argument in the corresponding subsequence whose length
is half of that of the original one. An implementation of binary search is given next.
First, we specify the main function.
Next, the implementation of binary search is given. The middle m of the sequence
A[l],. . ., A[r] is determined in line 7. If the element at this position is smaller than
k (line 8), we continue the search in the subsequence A[l],. . ., A[m-1], otherwise
in A[m+1],. . ., A[r] (line 8 and 9). The search stops either if the element has been
found or when the lower index l has become at least as large as the upper r (line 10)
which means that k is not contained in the sequence.
13
Algorithms and Data Structures (Liers)
{
4
5 int m;
6 do {
7 m = l + ((r - l) / 2);
8 if (k<A[m].key) r = m - 1;
9 else l = m + 1;
10 } while ((k!=A[m].key) && (l<=r));
11 if (k==A[m].key) return m;
12 else return 0;
}
13
For simplifying the analysis, we assume that the length of the sequence is a power
of two minus 1, i.e., n can be written as n = 2r − 1 with some appropriately chosen
r ∈ N. We need constant time for determining the middle of the sequence and for
the decision whether we need to continue the search in the subsequence to the left or
in that to the right. In the best case, we immediately find the correct element and
thus have a best-case running time of Θ(1). In the worst case, the element we look
for is either not contained in the sequence or is only found when the subsequence has
length one. Then, log n division steps and decisions for the correct subsequences have
to be performed. As each of these steps needs constant time, the worst-case running
time of binary search is Θ(log n). (One can show that also the average-case running
time is Θ(log n).)
14
5 Elementary Data Structures
push pop
5.1 Stacks
As an elementary data structure, we introduce a stack. A stack works like an in-tray
that people use for incoming mail in the sense that whatever is inserted last is returned
first (‘last-in first-out’ principle), see Figure 4. As elementary operations, a stack has
several functions available. The function empty returns 0, if no element is contained
in it, and 1 otherwise. Similarly, full also returns a Boolean value. push inserts
an element in the stack and pop deletes and returns the element that was inserted
last. As elements are only inserted and deleted at one ‘end’, a stack can easily be
implemented with an array of a maximum size that is given by STACKSIZE. Here,
elements are inserted and deleted from the ‘right’. In the following main function, the
stack is initialized (line 12). As an example, some elements are pushed into it and
finally removed again (lines 13–19). The last pop operation simply returns a message
saying the stack is empty.
1#include <stdio.h>
2#include <stdlib.h>
3#define STACKSIZE 4
5typedef struct {
6 int stack[STACKSIZE-1];
7 int stackpointer;
8} Stackstruct;
15
16main()
17{
18 Stackstruct s;
19 stackinit(&s);
20 push(&s,1);
21 push(&s,2);
15
Algorithms and Data Structures (Liers)
22 push(&s,3);
23 printf("%d\n",pop(&s));
24 printf("%d\n",pop(&s));
25 printf("%d\n",pop(&s));
26 printf("%d\n",pop(&s));
}
27
Next, the implementation of the stack functions is given. The variable stackpointer
stores the number of elements contained in the stack. In stackinit, this variable is
set to zero. In push, an element is inserted in the stack by inserting it into the array
at position stackpointer. pop then returns the element at position stackpointer
and ‘deletes’ the popped element by reducing the size of stackpointer by one.
10
15
24
16
5 Elementary Data Structures
1 5 2 9
1 5 2 9
11
Stacks are used, for example in modern programming languages. The compilers that
translate the source code of a formal language to an executable and languages like
Postscript entirely rely on stacks.
If a new item is inserted into the list next to some Node p, we first store it into a
new Node that we call r. Then, the successor of p is r (line 1 in the following source
code) , and the successor of r is q (line 2). In C, this looks as follows.
1 Node *q = p->next;
2 p->next = r;
3 r->next = q;
Deleting the node next to p can be performed as follows. We first link p->next to
p->next->next, see Figure 6. We then free the memory of p. (Here, we assume we
are already given p. In case we instead only know, say, the key of the Node we want
to remove, we first need to search for the Node with this key.)
17
Algorithms and Data Structures (Liers)
1 5 2
11
Figure 7: Deleting the node with key 9 from the singly-linked list.
1 Node *r = p->next;
2 p->next = p->next->next;
3 free(r);
Finally, we want to search for a specific item x in the list. This can easily be done
with a while-loop that starts at the beginning of the list and continues comparing the
nodes in the list with the element. While the correct element has not been found, the
next element is considered.
1 Node *pos = head;
2 while (pos != NULL && pos->next->dat.key != x.key ) pos = pos->next;
3 return pos;
Other advanced data structures exists, for example queues, priority queues, and
heaps. For each application, a different data structure might work best. Therefore,
one first specifies the necessary functionality and then decides which data structure
serves the needs. Here, let us briefly compare an array with a singly-linked linear
list. When using an array A, accessing an element at a certain position i can be done
in constant time by accessing A[i]. In contrast, a list does not have indices, and
indexing takes O(n). Inserting an element in an array or deleting it needs time O(n)
as discussed above, whereas it takes constant time in a linked list if inserted at the
beginning or at the end. If the node is not known next to which it has to be inserted,
insertion takes the time for searching the corresponding node plus constant time for
manipulating the links. Thus, depending on the application, a list can be suited
better than an array or vice versa. The sorting algorithms that we have introduced
earlier make frequent use of accessing elements at certain positions. Here, an array is
suited better than a list.
18
5 Elementary Data Structures
root
parent
child
leaf
if for any pair of vertices there exists a path in G between them. A connected graph
without cycles is called a tree. A rooted tree is a special tree in which a specific vertex
r is called the root. A vertex u is a child of another vertex v if u is a direct successor
of v on a path from the root. Then, u is the parent vertex. A vertex without a
child is called leaf. A binary tree is a tree in which each vertex has at most two child
vertices. An example can be seen in Figure 8. A binary search tree is a special binary
tree. Here, the children of a vertex can uniquely be assigned to be either a ‘left’ or a
‘right’ child. Left children have keys that are at most as large as that of their parents,
whereas the keys of the right children are at least as large as that of their parents.
The left and the right subtrees themselves are also binary search trees. Thus, in an
implementation, a vertex is specified by a pointer to the parent, a pointer to the
leftchild and a pointer to the rightchild. Depending on the situation, some of
these pointers may be NULL. For example, a parent vertex can have only one child
vertex and the parent of the root vertex is a NULL pointer.
1typedef int infotype;
2
For inserting a new vertex q into the binary tree, we first need to determine a
position where q can be inserted such that the resulting tree is still a binary search
tree. Then, q is inserted. In the source code that follows next, we start a path
at the root vertex. As long as we have not encountered a leaf vertex, we continue
the path in the left subtree if the key of q is smaller than that of the considered
vertex, otherwise in the right subtree (lines 7 – 10). Then we have found the vertex
r whose child can be q. We insert q by saying that its parent is r (line 12). If q is
the first vertex to be inserted, it becomes the root (line 13). Otherwise, depending
19
Algorithms and Data Structures (Liers)
17
10 19
5 12 21
on the value of its key, q is either in the left or in the right subtree of r (line 14).
Searching for a vertex in the tree with a specific key k is also simple. We start at
the root and continue going to child vertices. Whenever we consider a new vertex, we
compare its key with k. If k is smaller than that of the current vertex, we continue
the search at leftchild, otherwise at rightchild.
20
6 Advanced Programming
The search for the element with minimum (maximum, resp.) key can then be
performed by starting a path from the root, ending at the ‘leftmost’ (‘rightmost’,
resp.) leaf. In source code, the search for the minimum looks as follows.
1vertex* minimum(vertex *p)
2{
3 while (p->leftchild != NULL) p = p->leftchild;
4 return p;
5}
6 Advanced Programming
In practice, it is of utmost importance to have fast algorithms with good worst-case
performance at hand. Additionally, they need to be implemented efficiently. Further-
more, a careful documentation of the source code is indispensable for debugging and
maintaining purposes.
Elementary algorithms and data structures such as those introduced in this chap-
ter are used quite often in larger software projects. Both from a performance and
from a software-reusability point of view, they are often not implemented by the
programmer. Instead, fast implementations are used that are available in software
libraries. The standard C library stdlib implements, among other things, differ-
ent input and output methods, mathematical functions, quicksort and binary search.
For data structures and algorithms, (C++) libraries such as LEDA [6], boost[2], or
OGDF[4] exist. For linear algebra functions, the libraries BLAS[1] and LAPACK[3]
can be used.
Acknowledgments
Financial support by the DFG is acknowledged through project Li1675/1. The
author is grateful to Michael Jünger for providing C implementations of the pre-
sented algorithms and some variants of implementations for the presented data struc-
tures. Thanks to Gregor Pardella and Andreas Schmutzer for critically reading this
manuscript.
6.1 References
References
[1] Blas (basic linear algebra subprograms). http://www.netlib.org/blas/.
[2] boost c++ libraries. http://www.boost.org/.
21
Algorithms and Data Structures (Liers)
[5] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein.
Introduction to algorithms. MIT Press, Cambridge, MA, third edition, 2009.
[7] Donald E. Knuth. The art of computer programming. Vol. 3: Sorting and Search-
ing. Addison-Wesley, Upper Saddle River, NJ, 1998.
22