DOCSLIB.ORG

Introduction to Algorithms, 3Rd

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Thomas H. Cormen Charles E. Leiserson Ronald L. Rivest Clifford Stein Introduction to Algorithms Third Edition The MIT Press Cambridge, Massachusetts London, England c 2009 Massachusetts Institute of Technology All rights reserved. No part of this book may be reproduced in any form or by any electronic or mechanical means (including photocopying, recording, or information storage and retrieval) without permission in writing from the publisher. For information about special quantity discounts, please email special [email protected]. This book was set in Times Roman and Mathtime Pro 2 by the authors. Printed and bound in the United States of America. Library of Congress Cataloging-in-Publication Data Introduction to algorithms / Thomas H. Cormen ...[etal.].—3rded. p. cm. Includes bibliographical references and index. ISBN 978-0-262-03384-8 (hardcover : alk. paper)—ISBN 978-0-262-53305-8 (pbk. : alk. paper) 1. Computer programming. 2. Computer algorithms. I. Cormen, Thomas H. QA76.6.I5858 2009 005.1—dc22 2009008593 10987654321 Index This index uses the following conventions. Numbers are alphabetized as if spelled out; for example, “2-3-4 tree” is indexed as if it were “two-three-four tree.” When an entry refers to a place other than the main text, the page number is followed by a tag: ex. for exercise, pr. for problem, fig. for figure, and n. for footnote. A tagged page number often indicates the first page of an exercise or problem, which is not necessarily the page on which the reference actually appears. ˛.n/, 574 (set difference), 1159 (golden ratio), 59, 108 pr. jj y (conjugate of the golden ratio), 59 (flow value), 710 .n/ (Euler’s phi function), 943 (length of a string), 986 .n/-approximation algorithm, 1106, 1123 (set cardinality), 1161 o-notation, 50–51, 64 O-notation, 45 fig., 47–48, 64 (Cartesian product), 1162 O0-notation, 62 pr. (cross product), 1016 eO-notation, 62 pr. hi !-notation, 51 (sequence), 1166 -notation, 45 fig., 48–49, 64 (standard encoding), 1057 1 n -notation, 62 pr. k (choose), 1185 e-notation, 62 pr. kk(euclidean norm), 1222 ‚-notation, 44–47, 45 fig., 64 Š (factorial), 57 e‚-notation, 62 pr. de(ceiling), 54 bc(floor), 54 fg(set), 1158 p # (lower square root), 546 2 (set member), 1158 p 62 (not a set member), 1158 P" (upper square root), 546 ; Q (sum), 1145 (empty language), 1058 (product), 1148 (empty set), 1158 ! (adjacency relation), 1169 (subset), 1159 ; (reachability relation), 1170 (proper subset), 1159 ^ (AND), 697, 1071 W (such that), 1159 : (NOT), 1071 \ (set intersection), 1159 _ (OR), 697, 1071 [ (set union), 1159 ˚ (group operator), 939 ˝ (convolution operator), 901 1252 Index (closure operator), 1058 ADD-SUBARRAY, 805 pr. j (divides relation), 927 adjacency-list representation, 590 − (does-not-divide relation), 927 replaced by a hash table, 593 ex. (equivalent modulo n), 54, 1165 ex. adjacency-matrix representation, 591 6 (not equivalent modulo n), 54 adjacency relation (!), 1169 Œan (equivalence class modulo n), 928 adjacent vertices, 1169 Cn (addition modulo n), 940 admissible edge, 749 n (multiplication modulo n), 940 admissible network, 749–750 a . p / (Legendre symbol), 982 pr. adversary, 190 " (empty string), 986, 1058 aggregate analysis, 452–456 < (prefix relation), 986 for binary counters, 454–455 = (suffix relation), 986 for breadth-first search, 597 <x (above relation), 1022 for depth-first search, 606 // (comment symbol), 21 for Dijkstra’s algorithm, 661 (much-greater-than relation), 574 for disjoint-set data structures, 566–567, (much-less-than relation), 783 568 ex. P (polynomial-time reducibility relation), for dynamic tables, 465 1067, 1077 ex. for Fibonacci heaps, 518, 522 ex. for Graham’s scan, 1036 AA-tree, 338 for the Knuth-Morris-Pratt algorithm, 1006 abelian group, 940 for Prim’s algorithm, 636 ABOVE, 1024 for rod-cutting, 367 above relation (<x), 1022 for shortest paths in a dag, 655 absent child, 1178 for stack operations, 452–454 absolutely convergent series, 1146 aggregate flow, 863 absorption laws for sets, 1160 Akra-Bazzi method for solving a recurrence, abstract problem, 1054 112–113 acceptable pair of integers, 972 algorithm, 5 acceptance correctness of, 6 by an algorithm, 1058 origin of word, 42 by a finite automaton, 996 running time of, 25 accepting state, 995 as a technology, 13 accounting method, 456–459 Alice, 959 for binary counters, 458 ALLOCATE-NODE, 492 for dynamic tables, 465–466 ALLOCATE-OBJECT, 244 for stack operations, 457–458, 458 ex. allocation of objects, 243–244 Ackermann’s function, 585 all-pairs shortest paths, 644, 684–707 activity-selection problem, 415–422, 450 in dynamic graphs, 707 acyclic graph, 1170 in -dense graphs, 706 pr. relation to matroids, 448 pr. Floyd-Warshall algorithm for, 693–697, 706 add instruction, 23 Johnson’s algorithm for, 700–706 addition by matrix multiplication, 686–693, 706–707 of binary integers, 22 ex. by repeated squaring, 689–691 of matrices, 1220 alphabet, 995, 1057 modulo n (Cn), 940 ˛.n/, 574 of polynomials, 898 amortized analysis, 451–478 additive group modulo n, 940 accounting method of, 456–459 addressing, open, see open-address hash table aggregate analysis, 367, 452–456 Index 1253 for bit-reversal permutation, 472 pr. for set cover, 1117–1122, 1139 for breadth-first search, 597 for subset sum, 1128–1134, 1139 for depth-first search, 606 for traveling-salesman problem, 1111–1117, for Dijkstra’s algorithm, 661 1139 for disjoint-set data structures, 566–567, for vertex cover, 1108–1111, 1139 568 ex., 572 ex., 575–581, 581–582 ex. for weighted set cover, 1135 pr. for dynamic tables, 463–471 for 0-1 knapsack problem, 1137 pr., 1139 for Fibonacci heaps, 509–512, 517–518, approximation error, 836 520–522, 522 ex. approximation ratio, 1106, 1123 for the generic push-relabel algorithm, 746 approximation scheme, 1107 for Graham’s scan, 1036 APPROX-MIN-WEIGHT-VC, 1126 for the Knuth-Morris-Pratt algorithm, 1006 APPROX-SUBSET-SUM, 1131 for making binary search dynamic, 473 pr. APPROX-TSP-TOUR, 1112 potential method of, 459–463 APPROX-VERTEX-COVER, 1109 for restructuring red-black trees, 474 pr. arbitrage, 679 pr. for self-organizing lists with move-to-front, arc, see edge 476 pr. argument of a function, 1166–1167 for shortest paths in a dag, 655 arithmetic instructions, 23 for stacks on secondary storage, 502 pr. arithmetic, modular, 54, 939–946 for weight-balanced trees, 473 pr. arithmetic series, 1146 amortized cost arithmetic with infinities, 650 in the accounting method, 456 arm, 485 in aggregate analysis, 452 array, 21 in the potential method, 459 Monge, 110 pr. ancestor, 1176 passing as a parameter, 21 least common, 584 pr. articulation point, 621 pr. AND function (^), 697, 1071 assignment AND gate, 1070 multiple, 21 and, in pseudocode, 22 satisfying, 1072, 1079 antiparallel edges, 711–712 truth, 1072, 1079 antisymmetric relation, 1164 associative laws for sets, 1160 ANY-SEGMENTS-INTERSECT, 1025 associative operation, 939 approximation asymptotically larger, 52 by least squares, 835–839 asymptotically nonnegative, 45 of summation by integrals, 1154–1156 asymptotically positive, 45 approximation algorithm, 10, 1105–1140 asymptotically smaller, 52 for bin packing, 1134 pr. asymptotically tight bound, 45 for MAX-CNF satisfiability, 1127 ex. asymptotic efficiency, 43 for maximum clique, 1111 ex., 1134 pr. asymptotic lower bound, 48 for maximum matching, 1135 pr. asymptotic notation, 43–53, 62 pr. for maximum spanning tree, 1137 pr. and graph algorithms, 588 for maximum-weight cut, 1127 ex. and linearity of summations, 1146 for MAX-3-CNF satisfiability, 1123–1124, asymptotic upper bound, 47 1139 attribute of an object, 21 for minimum-weight vertex cover, augmentation of a flow, 716 1124–1127, 1139 augmenting data structures, 339–355 for parallel machine scheduling, 1136 pr. augmenting path, 719–720, 763 pr. randomized, 1123 authentication, 284 pr., 960–961, 964 1254 Index automaton best-case running time, 29 ex., 49 finite, 995 BFS, 595 string-matching, 996–1002 BIASED-RANDOM, 117 ex. auxiliary hash function, 272 biconnected component, 621 pr. auxiliary linear program, 886 big-oh notation, 45 fig., 47–48, 64 average-case running time, 28, 116 big-omega notation, 45 fig., 48–49, 64 AV L - I NSERT, 333 pr. bijective function, 1167 AVL tree, 333 pr., 337 binary character code, 428 axioms, for probability, 1190 binary counter analyzed by accounting method, 458 babyface, 602 ex. analyzed by aggregate analysis, 454–455 back edge, 609, 613 analyzed by potential method, 461–462 back substitution, 817 bit-reversed, 472 pr. BAD-SET-COVER-INSTANCE, 1122 ex. binary entropy function, 1187 BALANCE, 333 pr. binary gcd algorithm, 981 pr. balanced search tree binary heap, see heap AA-trees, 338 binary relation, 1163 AVL trees, 333 pr., 337 binary search, 39 ex. B-trees, 484–504 with fast insertion, 473 pr. k-neighbor trees, 338 in insertion sort, 39 ex. red-black trees, 308–338 in multithreaded merging, 799–800 scapegoat trees, 338 in searching B-trees, 499 ex. splay trees, 338, 482 BINARY-SEARCH, 799 treaps, 333 pr., 338 binary search tree, 286–307 2-3-4 trees, 489, 503 pr. AA-trees, 338 2-3 trees, 337, 504 AVL trees, 333 pr., 337 weight-balanced trees, 338, 473 pr. deletion from, 295–298, 299 ex. balls and bins, 133–134, 1215 pr. with equal keys, 303 pr. base-a pseudoprime, 967 insertion into, 294–295 base case, 65, 84 k-neighbor trees, 338 base, in DNA, 391 maximum key of, 291 basic feasible solution, 866 minimum key of, 291 basic solution, 866 optimal, 397–404, 413 basic variable, 855 predecessor in, 291–292 basis function, 835 querying, 289–294 Bayes’s theorem, 1194 randomly built, 299–303, 304 pr. BELLMAN-FORD, 651 right-converting of, 314 ex.
Recommended publications
  • 14 Augmenting Data Structures

    14 Augmenting Data Structures

    14 Augmenting Data Structures Some engineering situations require no more than a “textbook” data struc- ture—such as a doubly linked list, a hash table, or a binary search tree—but many others require a dash of creativity. Only in rare situations will you need to cre- ate an entirely new type of data structure, though. More often, it will suffice to augment a textbook data structure by storing additional information in it. You can then program new operations for the data structure to support the desired applica- tion. Augmenting a data structure is not always straightforward, however, since the added information must be updated and maintained by the ordinary operations on the data structure. This chapter discusses two data structures that we construct by augmenting red- black trees. Section 14.1 describes a data structure that supports general order- statistic operations on a dynamic set. We can then quickly find the ith smallest number in a set or the rank of a given element in the total ordering of the set. Section 14.2 abstracts the process of augmenting a data structure and provides a theorem that can simplify the process of augmenting red-black trees. Section 14.3 uses this theorem to help design a data structure for maintaining a dynamic set of intervals, such as time intervals. Given a query interval, we can then quickly find an interval in the set that overlaps it. 14.1 Dynamic order statistics Chapter 9 introduced the notion of an order statistic. Specifically, the ith order statistic of a set of n elements, where i 2 f1;2;:::;ng, is simply the element in the set with the ith smallest key.
  • Augmentation

    Augmentation

    TB Schardl 6.046J/18.410J October 02, 2009 Recitation 4 Augmentation The idea of augmentation is to add information to parts of a standard data structure to allow it to perform more complex tasks. You’ve practiced this concept already on Problem set 2, in order to allow skip lists to support O(log n) time RANK and SELECT methods. We’ll look at a similar prob- lem of creating “order statistic trees” by augmenting 2-3-4 trees to support RANK and SELECT. (The same methodology works for augmenting BSTs.) Order Statistic Trees Problem: Augment an ordinary 2-3-4 tree to support efficient RANK and SELECT-RANK methods without hurting the asymptotic performance of the normal tree operations. Idea: In each node, store the rank of the node in its subtree. An example order statistic tree is shown in Figure 1. 30 8 10 17 37 45 77 3 5 2 4 6 3 7 14 20 24 33 42 50 84 1 2 1 1 2 1 1 1 1 Figure 1: An example order statistic tree. The original values stored in the tree are shown in the top box in a darker gray, while their associated rank values are shown in the bottom box in a lighter gray. RANK,SELECT: We will examine SELECT, noting that the procedure for RANK is similar. Suppose we are searching for the ith order statistic. Starting from the root of the tree, look at the rank associated with the current node, n. If n.rank = i, return n. If n.rank > i, recursively SELECT the ith order statistic from the left child of n.
  • Persistent Predecessor Search and Orthogonal Point Location on the Word

    Persistent Predecessor Search and Orthogonal Point Location on the Word

    Persistent Predecessor Search and Orthogonal Point Location on the Word RAM∗ Timothy M. Chan† August 17, 2012 Abstract We answer a basic data structuring question (for example, raised by Dietz and Raman [1991]): can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of integers in 1,...,U under an arbitrary sequence of n insertions and deletions, with O(log log U) { } expected query time and expected amortized update time, and O(n) space. The query bound is optimal in U for linear-space structures and improves previous near-O((log log U)2) methods. The same method solves a fundamental problem from computational geometry: point location in orthogonal planar subdivisions (where edges are vertical or horizontal). We obtain the first static data structure achieving O(log log U) worst-case query time and linear space. This result is again optimal in U for linear-space structures and improves the previous O((log log U)2) method by de Berg, Snoeyink, and van Kreveld [1995]. The same result also holds for higher-dimensional subdivisions that are orthogonal binary space partitions, and for certain nonorthogonal planar subdivisions such as triangulations without small angles. Many geometric applications follow, including improved query times for orthogonal range reporting for dimensions 3 on the RAM. ≥ Our key technique is an interesting new van-Emde-Boas–style recursion that alternates be- tween two strategies, both quite simple. 1 Introduction Van Emde Boas trees [60, 61, 62] are fundamental data structures that support predecessor searches in O(log log U) time on the word RAM with O(n) space, when the n elements of the given set S come from a bounded integer universe 1,...,U (U n).
  • A New Approach to the Minimum Cut Problem

    A New Approach to the Minimum Cut Problem

    A New Approach to the Minimum Cut Problem DAVID R. KARGER Massachusetts Institute of Technology, Cambridge, Massachusetts AND CLIFFORD STEIN Dartmouth College, Hanover, New Hampshire Abstract. This paper presents a new approach to finding minimum cuts in undirected graphs. The fundamental principle is simple: the edges in a graph’s minimum cut form an extremely small fraction of the graph’s edges. Using this idea, we give a randomized, strongly polynomial algorithm that finds the minimum cut in an arbitrarily weighted undirected graph with high probability. The algorithm runs in O(n2log3n) time, a significant improvement over the previous O˜(mn) time bounds based on maximum flows. It is simple and intuitive and uses no complex data structures. Our algorithm can be parallelized to run in 51# with n2 processors; this gives the first proof that the minimum cut problem can be solved in 51#. The algorithm does more than find a single minimum cut; it finds all of them. With minor modifications, our algorithm solves two other problems of interest. Our algorithm finds all cuts with value within a multiplicative factor of a of the minimum cut’s in expected O˜(n2a) time, or in 51# with n2a processors. The problem of finding a minimum multiway cut of a graph into r pieces is solved in expected O˜(n2(r21)) time, or in 51# with n2(r21) processors. The “trace” of the algorithm’s execution on these two problems forms a new compact data structure for representing all small cuts and all multiway cuts in a graph. This data structure can be efficiently transformed into the more standard cactus representation for minimum cuts.
  • X-Fast and Y-Fast Tries

    X-Fast and Y-Fast Tries

    x-Fast and y-Fast Tries Outline for Today ● Bitwise Tries ● A simple ordered dictionary for integers. ● x-Fast Tries ● Tries + Hashing ● y-Fast Tries ● Tries + Hashing + Subdivision + Balanced Trees + Amortization Recap from Last Time Ordered Dictionaries ● An ordered dictionary is a data structure that maintains a set S of elements drawn from an ordered universe � and supports these operations: ● insert(x), which adds x to S. ● is-empty(), which returns whether S = Ø. ● lookup(x), which returns whether x ∈ S. ● delete(x), which removes x from S. ● max() / min(), which returns the maximum or minimum element of S. ● successor(x), which returns the smallest element of S greater than x, and ● predecessor(x), which returns the largest element of S smaller than x. Integer Ordered Dictionaries ● Suppose that � = [U] = {0, 1, …, U – 1}. ● A van Emde Boas tree is an ordered dictionary for [U] where ● min, max, and is-empty run in time O(1). ● All other operations run in time O(log log U). ● Space usage is Θ(U) if implemented deterministically, and O(n) if implemented using hash tables. ● Question: Is there a simpler data structure meeting these bounds? The Machine Model ● We assume a transdichotomous machine model: ● Memory is composed of words of w bits each. ● Basic arithmetic and bitwise operations on words take time O(1) each. ● w = Ω(log n). A Start: Bitwise Tries Tries Revisited ● Recall: A trie is a simple data 0 1 structure for storing strings. 0 1 0 1 ● Integers can be thought of as strings of bits. 1 0 1 1 0 ● Idea: Store integers in a bitwise trie.
  • Amortized Analysis

    Amortized Analysis

    Amortized Analysis Outline for Today ● Euler Tour Trees ● A quick bug fix from last time. ● Cartesian Trees Revisited ● Why could we construct them in time O(n)? ● Amortized Analysis ● Analyzing data structures over the long term. ● 2-3-4 Trees ● A better analysis of 2-3-4 tree insertions and deletions. Review from Last Time Dynamic Connectivity in Forests ● Consider the following special-case of the dynamic connectivity problem: Maintain an undirected forest G so that edges may be inserted an deleted and connectivity queries may be answered efficiently. ● Each deleted edge splits a tree in two; each added edge joins two trees and never closes a cycle. Dynamic Connectivity in Forests ● Goal: Support these three operations: ● link(u, v): Add in edge {u, v}. The assumption is that u and v are in separate trees. ● cut(u, v): Cut the edge {u, v}. The assumption is that the edge exists in the tree. ● is-connected(u, v): Return whether u and v are connected. ● The data structure we'll develop can perform these operations time O(log n) each. Euler Tours on Trees ● In general, trees do not have Euler tours. a b c d e f a c d b d f d c e c a ● Technique: replace each edge {u, v} with two edges (u, v) and (v, u). ● Resulting graph has an Euler tour. A Correction from Last Time The Bug ● The previous representation of Euler tour trees required us to store pointers to the first and last instance of each node in the tours.
  • Lecture Notes of CSCI5610 Advanced Data Structures

    Lecture Notes of CSCI5610 Advanced Data Structures

    Lecture Notes of CSCI5610 Advanced Data Structures Yufei Tao Department of Computer Science and Engineering Chinese University of Hong Kong July 17, 2020 Contents 1 Course Overview and Computation Models 4 2 The Binary Search Tree and the 2-3 Tree 7 2.1 The binary search tree . .7 2.2 The 2-3 tree . .9 2.3 Remarks . 13 3 Structures for Intervals 15 3.1 The interval tree . 15 3.2 The segment tree . 17 3.3 Remarks . 18 4 Structures for Points 20 4.1 The kd-tree . 20 4.2 A bootstrapping lemma . 22 4.3 The priority search tree . 24 4.4 The range tree . 27 4.5 Another range tree with better query time . 29 4.6 Pointer-machine structures . 30 4.7 Remarks . 31 5 Logarithmic Method and Global Rebuilding 33 5.1 Amortized update cost . 33 5.2 Decomposable problems . 34 5.3 The logarithmic method . 34 5.4 Fully dynamic kd-trees with global rebuilding . 37 5.5 Remarks . 39 6 Weight Balancing 41 6.1 BB[α]-trees . 41 6.2 Insertion . 42 6.3 Deletion . 42 6.4 Amortized analysis . 42 6.5 Dynamization with weight balancing . 43 6.6 Remarks . 44 1 CONTENTS 2 7 Partial Persistence 47 7.1 The potential method . 47 7.2 Partially persistent BST . 48 7.3 General pointer-machine structures . 52 7.4 Remarks . 52 8 Dynamic Perfect Hashing 54 8.1 Two random graph results . 54 8.2 Cuckoo hashing . 55 8.3 Analysis . 58 8.4 Remarks . 59 9 Binomial and Fibonacci Heaps 61 9.1 The binomial heap .
  • Lock-Free Concurrent Van Emde Boas Array

    Lock-Free Concurrent Van Emde Boas Array

    Lock-free concurrent van Emde Boas Array Ziyuan Guo Reiji Suda (Adviser) [email protected] [email protected] The University of Tokyo Graduate School of Information Science and Technology Tokyo, Japan ABSTRACT To unleash the power of modern multi-core processors, concur- Lock-based data structures have some potential issues such as dead- rent data structures are needed in many cases. Comparing to lock- lock, livelock, and priority inversion, and the progress can be de- based data structures, lock-free data structures can avoid some po- layed indefinitely if the thread that is holding locks cannot acquire tential issues such as deadlock, livelock, and priority inversion, and a timeslice from the scheduler. Lock-free data structures, which guarantees the progress [5]. guarantees the progress of some method call, can be used to avoid these problems. This poster introduces the first lock-free concur- 2 OBJECTIVES rent van Emde Boas Array which is a variant of van Emde Boas • Create a lock-free search tree based on van Emde Boas Tree. Tree. It’s linearizable and the benchmark shows significant per- • Get better performance and scalability. formance improvement comparing to other lock-free search trees • Linearizability, i.e., each method call should appear to take when the date set is large and dense enough. effect at some instant between its invocation and response [5]. CCS CONCEPTS • Computing methodologies → Concurrent algorithms. 3 RELATED WORK The base of our data structure is van Emde Boas Tree, whichis KEYWORDS named after P. van Emde Boas, the inventor of this data structure [7].
  • Fundamental Data Structures Contents

    Fundamental Data Structures Contents

    Fundamental Data Structures Contents 1 Introduction 1 1.1 Abstract data type ........................................... 1 1.1.1 Examples ........................................... 1 1.1.2 Introduction .......................................... 2 1.1.3 Defining an abstract data type ................................. 2 1.1.4 Advantages of abstract data typing .............................. 4 1.1.5 Typical operations ...................................... 4 1.1.6 Examples ........................................... 5 1.1.7 Implementation ........................................ 5 1.1.8 See also ............................................ 6 1.1.9 Notes ............................................. 6 1.1.10 References .......................................... 6 1.1.11 Further ............................................ 7 1.1.12 External links ......................................... 7 1.2 Data structure ............................................. 7 1.2.1 Overview ........................................... 7 1.2.2 Examples ........................................... 7 1.2.3 Language support ....................................... 8 1.2.4 See also ............................................ 8 1.2.5 References .......................................... 8 1.2.6 Further reading ........................................ 8 1.2.7 External links ......................................... 9 1.3 Analysis of algorithms ......................................... 9 1.3.1 Cost models ......................................... 9 1.3.2 Run-time analysis
  • Lock-Free Van Emde Boas Array Lock-Free Van Emde Boas

    Lock-Free Van Emde Boas Array Lock-Free Van Emde Boas

    Lock-free van Emde Boas Array Ziyuan Guo, Reiji Suda (Adviser) Graduate School of Information Science and Technology, The University of Tokyo Introduction Structure Insert Insert operation will put a descriptor on the first node Results that it should modify to effectively lock the entire path of This poster introduces the first lock-free concurrent van Emde The original plan was to implement a van Emde Boas Tree by the modification. Then help itself to finish the work by We compared the thoughput of our implementation with the Boas Array which is a variant of van Emde Boas Tree (vEB effectively using the cooperate technique as locks. However, execute CAS operations stored in the descriptor. lock-free binary search tree and skip-lists implemented by K. 1 bool insert(x) { tree). It's linearizable and the benchmark shows significant a vEB tree stores maximum and minimum elements on the 2 if (not leaf) { Fraser. performance improvement comparing to other lock-free search root node of each sub-tree, which create a severe scalability 3 do { Benchmark Environment 4 start_over: trees when the date set is large and dense enough. bottleneck. Thus, we choose to not store the maximum and 5 summary_snap = summary; • Intel Xeon E7-8890 v4 @ 2.2GHz Although van Emde Boas tree is not considered to be practical minimum element on each node, and use a fixed degree (64 6 if (summary_snap & (1 << HIGH(x))) 7 if (cluster[HIGH(x)].insert(LOW(x))) • 32GB DDR4 2133MHz before, it still can outperform traditional search trees in many on modern 64bit CPUs) for every node, then use a bit vec- 8 return true; 9 else • qemu-kvm 0.12.1.2-2.506.el6 10.1 situations, and there is no lock-free concurrent implementation tor summary to store whether the corresponding sub-tree is 10 goto start_over; 11 if (needs_help(summary_snap)) { • Kernel 5.1.15-300.fc30.x86 64 yet.
  • Questions for Computer Algorithms

    Questions for Computer Algorithms

    www.YoYoBrain.com - Accelerators for Memory and Learning Questions for computer algorithms Category: Default - (246 questions) Define: symmetric key encryption also known as secret-key encryption, is a cryptography technique that uses a single secret key to both encrypt and decrypt data. Define: cipher text encrypted text Define: asymmetric encryption also known as public-key encryption, relies on key pairs. In a key pair, there is one public key and one private key. Define: hash is a checksum that is unique to a specific file or piece of data. Can be used to verify that a file has not been modified after the hash was generated. Algorithms: describe insertion sort algorithm Start with empty hand and cards face down on the table. Remove one card at a time from the table and insert it into the correct position in left hand. To find the correct position for a card, we compare it with each of the cards already in the hand, from right to left. Algorithms: loop invariant A loop is a statement which allows code to be repeatedly executed;an invariant of a loop is a property that holds before (and after) each repetition Algorithms: selection sort algorithm Sorting n numbers stored in array A by first finding the smallest element of A and exchanging it with A[1], then the second smallest and exchanging it with A[2], etc. Algorithms: merge sort Recursive formula1.) Divide the n-element sequence into 2 sub sequences on n/2 elements each2.) Conquer - sort the 2 sub sequences using merge sort3.) Combine - merge the 2 sorted sub sequences to produce sorted answer.
  • Draft Version 2020-10-11

    Draft Version 2020-10-11

    Basic Data Structures for an Advanced Audience Patrick Lin Very Incomplete Draft Version 2020-10-11 Abstract I starting writing these notes for my fiancée when I was giving her an improvised course on Data Structures. The intended audience here has somewhat non-standard background for people learning this material: a number of advanced mathematics courses, courses in Automata Theory and Computational Complexity, but comparatively little exposure to Algorithms and Data Structures. Because of the heavy math background that included some advanced theoretical computer science, I felt comfortable with using more advanced mathematics and abstraction than one might find in a standard undergraduate course on Data Structures; on the other hand there are also some exercises which are purely exercises in implementational details. As such, these notes would require heavy revision in order to be used for more general audiences. I am heavily indebted to Pat Morin’s Open Data Structures and Jeff Erickson’s Algorithms, in particular the parts of the “Director’s Cut” of the latter that deal with randomization. Anyone familiar with these two sources will undoubtedly recognize their influences. I apologize for any strange notation, butchered analyses, bad analogies, misleading and/or factually incorrect statements, lack of references, etc. Due to the specific nature of these notes it can be hard to find time/reason to do large rewrites. Contents 1 Models of Computation for Data Structures 2 2 APIs (ADTs) vs Data Structures 4 3 Array-Based Data Structures 6 3.1 ArrayLists and Amortized Analysis . 6 3.2 Array{Stack,Queue,Deque}s ..................................... 9 3.3 Graphs and AdjacencyMatrices .