Algorithm Engineering for fundamental Sorting and Graph Problems

Fundamental Algorithms build a basis knowledge for every computer science undergraduate or a professional programmer. It is a set of basic techniques one can find in any (good) coursebook on algorithms and data structures. Thus, if one checks the contents of one such recent book by Mehlhorn and Sanders [105] he would find that we address most of the algorithmic problems covered in the book. In particular, we present current advances in such classical topics as sorting, graph traversals, shortest paths, minimum spanning trees, graph matchings and partitioning One can argue that all these problems are folklore with optimal worst-case behaviour. It is certainly true as long as the assumptions we use to derive the runtime bounds hold for a particular problem or available architecture at hand. In most of the coursebooks it is a Random Access Machine (RAM) model assuming that the input fits into the main memory of the computer and access time is unform throughout the size of the available memory. Unfortunately, it is often not the case for the real world architectures that posses a number of memory hierarchy layers including several levels of cache, main memory and an external hard drive. For instance, classical graph traversal algorithms become orders of magnitude slower as soon as data does not fit into the main memory and the operating system is forced to use a hard drive. Another problem for the classical coursebook algorithms is a rapidly growing parallelism. Currently it ranges from several cores in commodity home workstations (multicores) up to hundreds of cores available in Graphical Processing Units (GPUs). Classical approaches often become inefficient or even inapplicable in such settings. Even being on the safe side, that is in sequential RAM model, the worst-case optimality alone does not guarantee the best performance in practice. The reason for it is that the worst cases are rare in practice and thus the theoretically worse algorithms often perform better than their worst-case optimal counterparts. Clever heuristics often have further positive impact on the performance. In this thesis we try to close the gap between theoretically worst-case optimal classical algorithms and the real-world circumstances one face under the assumptions imposed by the data size, limited main memory or available parallelism.