# Lecture 2 February 12, 2003

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 6.897: Advanced Data Structures Spring 003 Prof. Erik Demaine Lecture February, 003 Scribe: Jeff Lindy Overview In the last lecture we considered the successor problem for a bounded universe of size u. We began looking at the van Emde Boas [3] data structure, which implements Insert, Delete, Successor, and Predecessor in O(lg ) time per operation. In this lecture we finish up van Emde Boas, and improve the space complexity from our original O(u) to O(n). We also look at perfect hashing (first static, then dynamic), using it to improve the space complexity of van Emde Boas and to implement a simpler data structure with the same running time, y-fast trees. van Emde Boas. Pseudocode for veb operations We start with pseudocode for Insert, Delete, and Successor. (Predecessor is symmetric to Successor.) Insert(x, S) if x <min[s]: swap x and min[s] if min[sub[s][high(x)]] = nil : // was empty Insert(low(x), sub[s][high(x)]) min[sub[s][high(x)]] low(x) else: Insert(high(x), summary[s]) if x > max[s]: max[s] x Delete(x, S) if min[s] = nil or x < min[s]: return if min[s] = x: i min[summary[s]]

2 x i S + min[sub[s][i]] min[s] x Delete(low(x, sub[w][high(x)]) if min[sub[s][high(x)]] = nil : // now empty Delete(high(x), summary[s]) // in this case, the first recursive call was cheap Successor(x, S) if x < min[s]: return min[s] if low(x) < max[sub[s][high(x)]] return high(x) S + Successor(low(x), sub[s][high(x)]) else: i Successor(high(x), summary[s]) return i S + min[sub[s][i]]. Tree view of van Emde Boas The van Emde Boas data structure can be viewed as a tree of trees. The upper and lower halves of the tree are of height, that is, we are cutting our tree in halves by level. The upper tree has u nodes, as does each of the subtrees hanging off its leaves. (These subtrees correspond to the sub[s] data structures in Section..) Summary Bits / sqrt(u) sqrt(u) sqrt(u) sqrt(u) sqrt(u) / Figure : In this case, we have the set, 9, 0, 5.

3 We can consider our set as a bit vector (of length 6) at the leaves. Mark all ancestors of present leaves. The function high(x) tells you how to walk through the upper tree. In the same way, low(x) tells you how to walk through the appropriate lower tree to reach x. For instance, consider querying for = 00 which is equivalent to right left left right ; high(9) = 0 ( right left ), low(9) = 0 ( left right )..3 Reducing Space in veb It is possible that this tree is wasting a lot of space. Suppose that in one of the subtrees there was nothing whatsoever? Instead of storing all substructures/lower trees explicitly, we can store sub[s] as a dynamic hash table and store only nonempty substructures. We perform an amortized analysis of space usage:. Hash Charge space for hashtable to nonempty substructures, each of which stores an element as min.. Summary Charge elements in the summary structure to the mins of corresponding substructures. When a substructure has just one element, stored in the min field, it does not store a hashtable, so that it can occupy just O() space. In all, the tree as described above uses O(n) space, whereas van Emde Boas takes more space, O(u), as originally considered [3]. For this approach to work, though, we need the following hashtable black box: BLACKBOX for hash table: Insert in O() time, amortized and expected Delete in O() time, amortized and expected Search in O() time, worse case Space is O(n) 3 Transdichotomous Model There are some issues with using the comparison model (too restrictive) and the standard unit cost RAM (too permissive, in that we can fit arbitrarily large data structures into single words). Between the two we have the transdichotomous model. This machine is a modified RAM, and is also called a word RAM, with some set size word upon which you can perform constant time arithmetic. We want to bridge problem size and machine model. So we need a word that is big enough (lg n) to index everything we are talking about. (This is a reasonable model since, say, a 64 bit word can index a truly enormous number of integers, 64.) With this model, we can manipulate a constant number of words in a constant time. 3

4 4 Perfect Hashing Perfect hashing is a way to implement hash tables such that the expected number of collisions is minimized. We do this by building a hash table of hash tables, where the choice of hash functions for the second level can be redone to avoid clobbering elements through hash collision. We ll start off with the static case; we already have all the elements, and won t be inserting new ones. how many elements hash to this slot a hash function from family H 7 h pointer to second level hash table entries n m i... h j m i entries first level hash table second level hash tables Figure : We re storing n elements from our universe U. h maps some u U into the first level hash table which is of size n. Each entry in the first level hash table has a count of how many elements hash there, as well as a second hash function h i which takes elements to a spot in the appropriate second level hash table. A set H of hash functions of the form h : U {0,,...,m } is called universal if {h H : h(x) = h(y)} = H /m for all x, y U, x y That is, the probability of a hash collision is equal to the size of the universe over the size of the table. Universal sets of hash functions exist. For instance, take key k, and write it in base m: Choose some other vector of this size at random: k = k 0, k,...,k r a = a 0, a,...,a r Then the hash function h a = r a i k i mod m i=0 4

5 is essentially weighting each k i, via a dot product. So letting the vector a vary, we have a family of hash functions, and it turns out to be universal. Suppose m i elements hash to bucket i (a slot in the first hash table). The expected number of collisions in a bucket is E[# of collisions in bucket i] = x y Pr{x and y collide} Because the second table is of size m i, this sum is equal to ( mi ) m i < (by Markov) The expected total size of all second-level tables is E[space] = E [ n m i i=0 Because the total number of conflicting pairs in the first level can be computed by counting pairs of elements in all second-level tables, this sum is equal to n + E [ n ( mi i=0 ] ) ] = n + ( ) n n < n So our expected space is about n. More specifically, the probability Pr[space > 4n] <. If we clobber an element, we pick some other hash function for that bucket. We will need to choose new hash functions only an expected constant number of times per bucket, because we have a constant probability of success each time. 4. Dynamic Perfect Hashing Making a perfect hash table dynamic is relatively straightforward, and can be done by keeping track of how many elements we have inserted or deleted, and rebuilding (shrinking or growing) the entire hash table. This result is due to Dietzfelbinger et al. [4]. Suppose at time t there are n elements. Construct a static perfect hash table for n elements. If we insert another n elements, we rebuild again, this time a static perfect hash table for 4n elements. As before, whenever there s a collision at the second-level hash table, just rebuild the entire secondlevel table with a new choice of hash function from our family H. This won t happen very often, so amortized the cost is low. If we delete elements until we have n /4, we rebuild for n instead of n. (If we delete enough, we rebuild at half the size.) All operations take amortized O() time. 5

6 5 y-fast Trees 5. Operation Costs y-fast trees [, ] accomplish the same running times as van Emde Boas O(lg ) for Insert, Delete, Successor, and Predecessor but they are simple once you have dynamic perfect hashing in place. We can define correspondences u U bit string path in a balanced binary search tree. For all x in our set, we will store a dynamic perfect hash table of all prefixes of these strings. Unfortunately, this structure requires O(n ) space, because there are n elements, each of which have prefixes. Also, insertions and deletions cost. We ll fix these high costs later. What does this structure do for Successor, though? To find a successor, we binary search for the lowest filled node on the path to x. We ask, Is half the path there? for successively smaller halves. It takes O(lg ) time to find this node. Suppose we have each node store the min and max element for its subtree (in the hash table entry). This change adds on some constant cost for space. Also, we can maintain a linked list of the entire set of occupied leaves. Then we can find the successor and the predecessor of x in O() time given what we have so far. Using this structure, we can perform Successor/Predecessor in O(lg ) time, and Insert/Delete in O() time, using O(n ) space. 5. Indirection We cluster the n present elements into consecutive groups of size Θ(). Within a group, we use a balanced binary search tree to do Insert/Delete/Successor/Predecessor in O(lg ) time. We use hash table as above to store one representative element per group O(n) space If a search in the hashtable narrows down to groups, look in both. Insert and Delete are delayed by the groups, so it works out to be O() amortized to update the hash table, and O(lg ) total. 6

7 n elements stored veb Figure 3: Using indirection in y-fast trees. References [] Dan E. Willard, Log-logarithmic worst-case range queries are possible in space Θ(n), Information Processing Letters, 7: [] Dan E. Willard, New trie data structures which support very fast search operations, Journal of Computer and System Sciences, 8(3): [3] P. van Emde Boas, Preserving order in a forest in less than logarithmic time and linear space, Information Processing Letters, 6:80 8, 977. [4] M. Dietzfelbinger, A. Karlin, K. Mehlhorn, F. Meyer auf der Heide, H. Rohnert, and R. E. Tarjan, Dynamic perfect hashing: upper and lower bounds, SIAM Journal on Computing, 3:738 76,

### Analysis of Algorithms I: Binary Search Trees

Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary

### Universal hashing. In other words, the probability of a collision for two different keys x and y given a hash function randomly chosen from H is 1/m.

Universal hashing No matter how we choose our hash function, it is always possible to devise a set of keys that will hash to the same slot, making the hash scheme perform poorly. To circumvent this, we

### Binary Search Trees. A Generic Tree. Binary Trees. Nodes in a binary search tree ( B-S-T) are of the form. P parent. Key. Satellite data L R

Binary Search Trees A Generic Tree Nodes in a binary search tree ( B-S-T) are of the form P parent Key A Satellite data L R B C D E F G H I J The B-S-T has a root node which is the only node whose parent

### 1 2-3 Trees: The Basics

CS10: Data Structures and Object-Oriented Design (Fall 2013) November 1, 2013: 2-3 Trees: Inserting and Deleting Scribes: CS 10 Teaching Team Lecture Summary In this class, we investigated 2-3 Trees in

### Cpt S 223. School of EECS, WSU

Priority Queues (Heaps) 1 Motivation Queues are a standard mechanism for ordering tasks on a first-come, first-served basis However, some tasks may be more important or timely than others (higher priority)

### Symbol Tables. IE 496 Lecture 13

Symbol Tables IE 496 Lecture 13 Reading for This Lecture Horowitz and Sahni, Chapter 2 Symbol Tables and Dictionaries A symbol table is a data structure for storing a list of items, each with a key and

### Algorithms Chapter 12 Binary Search Trees

Algorithms Chapter 1 Binary Search Trees Outline Assistant Professor: Ching Chi Lin 林 清 池 助 理 教 授 chingchi.lin@gmail.com Department of Computer Science and Engineering National Taiwan Ocean University

### Chapter Objectives. Chapter 9. Sequential Search. Search Algorithms. Search Algorithms. Binary Search

Chapter Objectives Chapter 9 Search Algorithms Data Structures Using C++ 1 Learn the various search algorithms Explore how to implement the sequential and binary search algorithms Discover how the sequential

### An Evaluation of Self-adjusting Binary Search Tree Techniques

SOFTWARE PRACTICE AND EXPERIENCE, VOL. 23(4), 369 382 (APRIL 1993) An Evaluation of Self-adjusting Binary Search Tree Techniques jim bell and gopal gupta Department of Computer Science, James Cook University,

### A Hybrid Chaining Model with AVL and Binary Search Tree to Enhance Search Speed in Hashing

, pp.185-194 http://dx.doi.org/10.14257/ijhit.2015.8.3.18 A Hybrid Chaining Model with AVL and Binary Search Tree to Enhance Search Speed in Hashing 1 Akshay Saxena, 2 Harsh Anand, 3 Tribikram Pradhan

### Complexity of Union-Split-Find Problems. Katherine Jane Lai

Complexity of Union-Split-Find Problems by Katherine Jane Lai S.B., Electrical Engineering and Computer Science, MIT, 2007 S.B., Mathematics, MIT, 2007 Submitted to the Department of Electrical Engineering

### Orthogonal Range Searching in 2D with Ball Inheritance Mads Ravn,

Orthogonal Range Searching in 2D with Ball Inheritance Mads Ravn, 20071580 Master s Thesis, Computer Science June 2015 Advisor: Kasper Green Larsen AARHUS AU UNIVERSITY DEPARTMENT OF COMPUTER SCIENCE ii

### Lecture 1: Data Storage & Index

Lecture 1: Data Storage & Index R&G Chapter 8-11 Concurrency control Query Execution and Optimization Relational Operators File & Access Methods Buffer Management Disk Space Management Recovery Manager

### B+ Tree Properties B+ Tree Searching B+ Tree Insertion B+ Tree Deletion Static Hashing Extendable Hashing Questions in pass papers

B+ Tree and Hashing B+ Tree Properties B+ Tree Searching B+ Tree Insertion B+ Tree Deletion Static Hashing Extendable Hashing Questions in pass papers B+ Tree Properties Balanced Tree Same height for paths

### A. V. Gerbessiotis CS Spring 2014 PS 3 Mar 24, 2014 No points

A. V. Gerbessiotis CS 610-102 Spring 2014 PS 3 Mar 24, 2014 No points Problem 1. Suppose that we insert n keys into a hash table of size m using open addressing and uniform hashing. Let p(n, m) be the

### Faster Deterministic Dictionaries

1 Appeared at SODA 2000, p. 487 493. ACM-SIAM. Available on-line at http://www.brics.dk/~pagh/papers/ Faster Deterministic Dictionaries Rasmus Pagh Abstract We consider static dictionaries over the universe

### CS 2112 Spring 2014. 0 Instructions. Assignment 3 Data Structures and Web Filtering. 0.1 Grading. 0.2 Partners. 0.3 Restrictions

CS 2112 Spring 2014 Assignment 3 Data Structures and Web Filtering Due: March 4, 2014 11:59 PM Implementing spam blacklists and web filters requires matching candidate domain names and URLs very rapidly

### Persistent Data Structures

6.854 Advanced Algorithms Lecture 2: September 9, 2005 Scribes: Sommer Gentry, Eddie Kohler Lecturer: David Karger Persistent Data Structures 2.1 Introduction and motivation So far, we ve seen only ephemeral

### Cloud and Big Data Summer School, Stockholm, Aug., 2015 Jeffrey D. Ullman

Cloud and Big Data Summer School, Stockholm, Aug., 2015 Jeffrey D. Ullman To motivate the Bloom-filter idea, consider a web crawler. It keeps, centrally, a list of all the URL s it has found so far. It

### Multi-Way Search Trees (B Trees)

Multi-Way Search Trees (B Trees) Multiway Search Trees An m-way search tree is a tree in which, for some integer m called the order of the tree, each node has at most m children. If n

### Operations: search;; min;; max;; predecessor;; successor. Time O(h) with h height of the tree (more on later).

Binary search tree Operations: search;; min;; max;; predecessor;; successor. Time O(h) with h height of the tree (more on later). Data strutcure fields usually include for a given node x, the following

### Binary Search Trees. parent. right. left

Binary Search Trees Binary search trees provide a data structure which efficiently supports all six dictionary operations. A binary tree is a rooted tree where each node contains at most two children.

### Binary Heap Algorithms

CS Data Structures and Algorithms Lecture Slides Wednesday, April 5, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005 2009 Glenn G. Chappell

### Quiz 1 Solutions. (a) T F The height of any binary search tree with n nodes is O(log n). Explain:

Introduction to Algorithms March 9, 2011 Massachusetts Institute of Technology 6.006 Spring 2011 Professors Erik Demaine, Piotr Indyk, and Manolis Kellis Quiz 1 Solutions Problem 1. Quiz 1 Solutions True

### Binary Search Trees. Robert E. Tarjan Princeton University & Intertrust Technologies. Heidelberg Laureate Forum September 23, 2016

Binary Search Trees Robert E. Tarjan Princeton University & Intertrust Technologies Heidelberg Laureate Forum September 23, 206 ObservaIons Over the last 50+ years, computer scienists have developed many

### Tables so far. set() get() delete() BST Average O(lg n) O(lg n) O(lg n) Worst O(n) O(n) O(n) RB Tree Average O(lg n) O(lg n) O(lg n)

Hash Tables Tables so far set() get() delete() BST Average O(lg n) O(lg n) O(lg n) Worst O(n) O(n) O(n) RB Tree Average O(lg n) O(lg n) O(lg n) Worst O(lg n) O(lg n) O(lg n) Table naïve array implementation

### Big Data and Scripting. Part 4: Memory Hierarchies

1, Big Data and Scripting Part 4: Memory Hierarchies 2, Model and Definitions memory size: M machine words total storage (on disk) of N elements (N is very large) disk size unlimited (for our considerations)

### Balanced Trees Part One

Balanced Trees Part One Balanced Trees Balanced trees are surprisingly versatile data structures. Many programming languages ship with a balanced tree library. C++: std::map / std::set Java: TreeMap /

### A binary search tree is a binary tree with a special property called the BST-property, which is given as follows:

Chapter 12: Binary Search Trees A binary search tree is a binary tree with a special property called the BST-property, which is given as follows: For all nodes x and y, if y belongs to the left subtree

### Unit 6: Binary Trees Part 2. Deletion. Deletion by merging. Deletion by merging Deletion by copying. Engineering 4892: Data Structures.

Unit : Binary Trees Part 2 Engineering 92: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland 1 Deletion Deletion by copying 1 Balanced trees AVL trees July 11,

### root node level: internal node edge leaf node CS@VT Data Structures & Algorithms 2000-2009 McQuain

inary Trees 1 A binary tree is either empty, or it consists of a node called the root together with two binary trees called the left subtree and the right subtree of the root, which are disjoint from each

### Labworks 1: Binary Search Trees and Red-Black trees

Labworks 1: Binary Search Trees and Red-Black trees October 12, 2016 Deadline for these labworks: October 26 2016 How? Make an archive with the source files of your implementation, and send it by email

### Balanced search trees

Lecture 8 Balanced search trees 8.1 Overview In this lecture we discuss search trees as a method for storing data in a way that supports fast insert, lookup, and delete operations. (Data structures handling

### Sidebar: Data Structures

Sidebar: Data Structures A data structure is a collection of algorithms for storing and retrieving information. The operations that store information are called updates, and the operations that retrieve

### Problem. Indexing with B-trees. Indexing. Primary Key Indexing. B-trees. B-trees: Example. primary key indexing

Problem Given a large collection of records, Indexing with B-trees find similar/interesting things, i.e., allow fast, approximate queries Anastassia Ailamaki http://www.cs.cmu.edu/~natassa 2 Indexing Primary

### CS271: Data Structures. Binary Search Trees

CS271: Data Structures Binary Search Trees This project has three parts: an implementation of a binary search tree class, a testing plan, and an experiment in tree height. 1. PART 1 Implement a binary

### 2 Exercises and Solutions

2 Exercises and Solutions Most of the exercises below have solutions but you should try first to solve them. Each subsection with solutions is after the corresponding subsection with exercises. 2.1 Sorting

### Cache-Oblivious Search Trees via Trees of Small Height

Cache-Oblivious Search Trees via Trees of Small Height Gerth Stølting Brodal BRICS University of Aarhus Joint work with Rolf Fagerberg and Riko Jacob To be presented at the 13th Annual ACM-SIAM Symposium

### 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

### Searching and Hashing

Searching and Hashing Sequential Search Property: Sequential search (array implementation) uses N+1 comparisons for an unsuccessful search (always). Unsuccessful Search: (n) Successful Search: item is

### Lecture 7: Approximation via Randomized Rounding

Lecture 7: Approximation via Randomized Rounding Often LPs return a fractional solution where the solution x, which is supposed to be in {0, } n, is in [0, ] n instead. There is a generic way of obtaining

### Persistent Data Structures and Planar Point Location

Persistent Data Structures and Planar Point Location Inge Li Gørtz Persistent Data Structures Ephemeral Partial persistence Full persistence Confluent persistence V1 V1 V1 V1 V2 q ue V2 V2 V5 V2 V4 V4

### Dynamic 3-sided Planar Range Queries with Expected Doubly Logarithmic Time

Dynamic 3-sided Planar Range Queries with Expected Doubly Logarithmic Time Gerth Stølting Brodal 1, Alexis C. Kaporis 2, Spyros Sioutas 3, Konstantinos Tsakalidis 1, Kostas Tsichlas 4 1 MADALGO, Department

### Announcements. CSE332: Data Abstractions. Lecture 9: B Trees. Today. Our goal. M-ary Search Tree. M-ary Search Tree. Ruth Anderson Winter 2011

Announcements CSE2: Data Abstractions Project 2 posted! Partner selection due by 11pm Tues 1/25 at the latest. Homework due Friday Jan 28 st at the BEGINNING of lecture Lecture 9: B Trees Ruth Anderson

### COT5405 Analysis of Algorithms Homework 3 Solutions

COT0 Analysis of Algorithms Homework 3 Solutions. Prove or give a counter example: (a) In the textbook, we have two routines for graph traversal - DFS(G) and BFS(G,s) - where G is a graph and s is any

### CSE 5311 Homework 2 Solution

CSE 5311 Homework 2 Solution Problem 6.2-6 Show that the worst-case running time of MAX-HEAPIFY on a heap of size n is Ω(lg n). (Hint: For a heap with n nodes, give node values that cause MAX- HEAPIFY

### Answers to Homework 1

Answers to Homework 1 p. 13 1.2 3 What is the smallest value of n such that an algorithm whose running time is 100n 2 runs faster than an algorithm whose running time is 2 n on the same machine? Find the

### A binary search tree or BST is a binary tree that is either empty or in which the data element of each node has a key, and:

Binary Search Trees 1 The general binary tree shown in the previous chapter is not terribly useful in practice. The chief use of binary trees is for providing rapid access to data (indexing, if you will)

### Multiway Search Tree (MST)

Multiway Search Tree (MST) Generalization of BSTs Suitable for disk MST of order n: Each node has n or fewer sub-trees S1 S2. Sm, m n Each node has n-1 or fewer keys K1 Κ2 Κm-1 : m-1 keys in ascending

### CS711008Z Algorithm Design and Analysis

CS711008Z Algorithm Design and Analysis Lecture 7 Binary heap, binomial heap, and Fibonacci heap 1 Dongbo Bu Institute of Computing Technology Chinese Academy of Sciences, Beijing, China 1 The slides were

### Confluently Persistent Tries for Efficient Version Control

Confluently Persistent Tries for Efficient Version Control Erik D. Demaine Stefan Langerman Eric Price Abstract We consider a data-structural problem motivated by version control of a hierarchical directory

### Krishna Institute of Engineering & Technology, Ghaziabad Department of Computer Application MCA-213 : DATA STRUCTURES USING C

Tutorial#1 Q 1:- Explain the terms data, elementary item, entity, primary key, domain, attribute and information? Also give examples in support of your answer? Q 2:- What is a Data Type? Differentiate

### Binary Heaps * * * * * * * / / \ / \ / \ / \ / \ * * * * * * * * * * * / / \ / \ / / \ / \ * * * * * * * * * *

Binary Heaps A binary heap is another data structure. It implements a priority queue. Priority Queue has the following operations: isempty add (with priority) remove (highest priority) peek (at highest

### Multimedia Communications. Huffman Coding

Multimedia Communications Huffman Coding Optimal codes Suppose that a i -> w i C + is an encoding scheme for a source alphabet A={a 1,, a N }. Suppose that the source letter a 1,, a N occur with relative

### Lecture Notes on Binary Search Trees

Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 17 October 23, 2014 1 Introduction In this lecture, we will continue considering associative

### TIE-20106 1 TIE-20106 2

TIE-20106 1 1 List structures In this chapter, a few simple data structures (stack and queue) that can be implemented with arrays and/or lists are covered. Two more complex structures based on lists are

### Binary Trees and Huffman Encoding Binary Search Trees

Binary Trees and Huffman Encoding Binary Search Trees Computer Science E119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Motivation: Maintaining a Sorted Collection of Data A data dictionary

### Persistent Data Structures and Planar Point Location. Inge Li Gørtz

Persistent Data Structures and Planar Point Location Inge Li Gørtz Persistent Data Structures Ephemeral Partial persistence Full persistence Confluent persistence V1 V1 V1 V1 V2 q ue V2 V2 V5 V2 V4 V4

### IMPROVING PERFORMANCE OF RANDOMIZED SIGNATURE SORT USING HASHING AND BITWISE OPERATORS

Volume 2, No. 3, March 2011 Journal of Global Research in Computer Science RESEARCH PAPER Available Online at www.jgrcs.info IMPROVING PERFORMANCE OF RANDOMIZED SIGNATURE SORT USING HASHING AND BITWISE

### DATABASE DESIGN - 1DL400

DATABASE DESIGN - 1DL400 Spring 2015 A course on modern database systems!! http://www.it.uu.se/research/group/udbl/kurser/dbii_vt15/ Kjell Orsborn! Uppsala Database Laboratory! Department of Information

### BINARY SEARCH TREE PERFORMANCE

BINARY SEARCH TREE PERFORMANCE Operation Best Time Average Time Worst Time (on a tree of n nodes) Find Insert Delete O(lg n)?? O(lg n)?? O(n) Fastest Running Time The find, insert and delete algorithms

### Binary Search Trees 1. Binary Search Trees

Binary Search Trees Binary Search Trees class node { int key; node *left, *right, *parent; }; A Binary Search Tree is a binary tree with the following properties: Given a node x in the tree if y is a node

### ! Insert a value with specified key. ! Search for value given key. ! Delete value with given key. ! O(log N) time per op.

Symbol Table Review 4.4 Balanced Trees Symbol table: key-value pair abstraction.! a value with specified key.! for value given key.! value with given key. Randomized BST.! O(log ) time per op. unless you

### 1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D.

1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D. base address 2. The memory address of fifth element of an array can be calculated

### CSE373: Data Structures & Algorithms Lecture 14: Hash Collisions. Linda Shapiro Spring 2016

CSE373: Data Structures & Algorithms Lecture 14: Hash Collisions Linda Shapiro Spring 2016 Announcements Friday: Review List and go over answers to Practice Problems 2 Hash Tables: Review Aim for constant-time

### Algorithms. Margaret M. Fleck. 18 October 2010

Algorithms Margaret M. Fleck 18 October 2010 These notes cover how to analyze the running time of algorithms (sections 3.1, 3.3, 4.4, and 7.1 of Rosen). 1 Introduction The main reason for studying big-o

### Binary Search Trees. Each child can be identied as either a left or right. parent. right. A binary tree can be implemented where each node

Binary Search Trees \I think that I shall never see a poem as lovely as a tree Poem's are wrote by fools like me but only G-d can make atree \ {Joyce Kilmer Binary search trees provide a data structure

### CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 221] edge. parent

CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 221] Trees Important terminology: edge root node parent Some uses of trees: child leaf model arithmetic expressions and other expressions

### CS 4310 HOMEWORK SET 1

CS 4310 HOMEWORK SET 1 PAUL MILLER Section 2.1 Exercises Exercise 2.1-1. Using Figure 2.2 as a model, illustrate the operation of INSERTION-SORT on the array A = 31, 41, 59, 26, 41, 58. Solution: Assume

### D1.1 Service Discovery system: Load balancing mechanisms

D1.1 Service Discovery system: Load balancing mechanisms VERSION 1.0 DATE 2011 EDITORIAL MANAGER Eddy Caron AUTHORS STAFF Eddy Caron, Cédric Tedeschi Copyright ANR SPADES. 08-ANR-SEGI-025. Contents Introduction

### Chapter 14 The Binary Search Tree

Chapter 14 The Binary Search Tree In Chapter 5 we discussed the binary search algorithm, which depends on a sorted vector. Although the binary search, being in O(lg(n)), is very efficient, inserting a

### Binary Search Trees. Data in each node. Larger than the data in its left child Smaller than the data in its right child

Binary Search Trees Data in each node Larger than the data in its left child Smaller than the data in its right child FIGURE 11-6 Arbitrary binary tree FIGURE 11-7 Binary search tree Data Structures Using

### Quick Sort. Implementation

Implementation Next, recall that our goal is to partition all remaining elements based on whether they are smaller than or greater than the pivot We will find two entries: One larger than the pivot (staring

### Data Warehousing und Data Mining

Data Warehousing und Data Mining Multidimensionale Indexstrukturen Ulf Leser Wissensmanagement in der Bioinformatik Content of this Lecture Multidimensional Indexing Grid-Files Kd-trees Ulf Leser: Data

### A binary heap is a complete binary tree, where each node has a higher priority than its children. This is called heap-order property

CmSc 250 Intro to Algorithms Chapter 6. Transform and Conquer Binary Heaps 1. Definition A binary heap is a complete binary tree, where each node has a higher priority than its children. This is called

### Binary Search Trees CMPSC 122

Binary Search Trees CMPSC 122 Note: This notes packet has significant overlap with the first set of trees notes I do in CMPSC 360, but goes into much greater depth on turning BSTs into pseudocode than

### Learning Outcomes. COMP202 Complexity of Algorithms. Binary Search Trees and Other Search Trees

Learning Outcomes COMP202 Complexity of Algorithms Binary Search Trees and Other Search Trees [See relevant sections in chapters 2 and 3 in Goodrich and Tamassia.] At the conclusion of this set of lecture

### The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge,

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge, cheapest first, we had to determine whether its two endpoints

### Outline BST Operations Worst case Average case Balancing AVL Red-black B-trees. Binary Search Trees. Lecturer: Georgy Gimel farb

Binary Search Trees Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 27 1 Properties of Binary Search Trees 2 Basic BST operations The worst-case time complexity of BST operations

### Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology Professors Erik Demaine and Shafi Goldwasser Quiz 1.

Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Quiz 1 Quiz 1 Do not open this quiz booklet until you are directed

### File Systems: Fundamentals

Files What is a file? A named collection of related information recorded on secondary storage (e.g., disks) File Systems: Fundamentals File attributes Name, type, location, size, protection, creator, creation

### INTRODUCTION The collection of data that makes up a computerized database must be stored physically on some computer storage medium.

Chapter 4: Record Storage and Primary File Organization 1 Record Storage and Primary File Organization INTRODUCTION The collection of data that makes up a computerized database must be stored physically

### Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

### Heap. Binary Search Tree. Heaps VS BSTs. < el el. Difference between a heap and a BST:

Heaps VS BSTs Difference between a heap and a BST: Heap el Binary Search Tree el el el < el el Perfectly balanced at all times Immediate access to maximal element Easy to code Does not provide efficient

### Lecture 7: Hashing III: Open Addressing

Lecture 7: Hashing III: Open Addressing Lecture Overview Open Addressing, Probing Strategies Uniform Hashing, Analysis Cryptographic Hashing Readings CLRS Chapter.4 (and.3.3 and.5 if interested) Open Addressing

### Full and Complete Binary Trees

Full and Complete Binary Trees Binary Tree Theorems 1 Here are two important types of binary trees. Note that the definitions, while similar, are logically independent. Definition: a binary tree T is full

### Data Structure. Lecture 3

Data Structure Lecture 3 Data Structure Formally define Data structure as: DS describes not only set of objects but the ways they are related, the set of operations which may be applied to the elements

### Previous Lectures. B-Trees. External storage. Two types of memory. B-trees. Main principles

B-Trees Algorithms and data structures for external memory as opposed to the main memory B-Trees Previous Lectures Height balanced binary search trees: AVL trees, red-black trees. Multiway search trees:

### Sequential Data Structures

Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year

### Symbol Tables. Introduction

Symbol Tables Introduction A compiler needs to collect and use information about the names appearing in the source program. This information is entered into a data structure called a symbol table. The

### Searching and Search Trees II

Data structures and algorithms Part 9 Searching and Search Trees II Petr Felkel 10.12. 2007 Topics Red-Black tree Insert Delete B-Tree Motivation Search Insert Delete Based on: [Cormen, Leiserson, Rivest:

### Merge Sort. 2004 Goodrich, Tamassia. Merge Sort 1

Merge Sort 7 2 9 4 2 4 7 9 7 2 2 7 9 4 4 9 7 7 2 2 9 9 4 4 Merge Sort 1 Divide-and-Conquer Divide-and conquer is a general algorithm design paradigm: Divide: divide the input data S in two disjoint subsets

### Hashing? Principles of Database Management Systems. 4.2: Hashing Techniques. Hashing. Example hash function

Principles of Database Management Systems 4: Hashing Techniques Pekka Kilpeläinen (after Stanford CS45 slide originals by Hector Garcia-Molina, Jeff Ullman and Jennifer Widom) Hashing? Locating the storage

### Union-Find Problem. Using Arrays And Chains

Union-Find Problem Given a set {,,, n} of n elements. Initially each element is in a different set. ƒ {}, {},, {n} An intermixed sequence of union and find operations is performed. A union operation combines

### Persistent Binary Search Trees

Persistent Binary Search Trees Datastructures, UvA. May 30, 2008 0440949, Andreas van Cranenburgh Abstract A persistent binary tree allows access to all previous versions of the tree. This paper presents

### COS 511: Foundations of Machine Learning. Rob Schapire Lecture #14 Scribe: Qian Xi March 30, 2006

COS 511: Foundations of Machine Learning Rob Schapire Lecture #14 Scribe: Qian Xi March 30, 006 In the previous lecture, we introduced a new learning model, the Online Learning Model. After seeing a concrete

### Chapter 4. Trees. 4.1 Basics

Chapter 4 Trees 4.1 Basics A tree is a connected graph with no cycles. A forest is a collection of trees. A vertex of degree one, particularly in a tree, is called a leaf. Trees arise in a variety of applications.

### Lecture 4: Balanced Binary Search Trees

Lecture 4 alanced inar Search Trees 6.006 Fall 009 Lecture 4: alanced inar Search Trees Lecture Overview The importance of being balanced VL trees Definition alance Insert Other balanced trees Data structures