# Data Structures. Jaehyun Park. CS 97SI Stanford University. June 29, 2015

Save this PDF as:

Size: px
Start display at page:

Download "Data Structures. Jaehyun Park. CS 97SI Stanford University. June 29, 2015"

## Transcription

1 Data Structures Jaehyun Park CS 97SI Stanford University June 29, 2015

2 Typical Quarter at Stanford void quarter() { while(true) { // no break :( task x = GetNextTask(tasks); process(x); // new tasks may enter } } GetNextTask() decides the order of the tasks 2

3 Deciding the Order of the Tasks Possible behaviors of GetNextTask(): Returns the newest task (stack) Returns the oldest task (queue) Returns the most urgent task (priority queue) Returns the easiest task (priority queue) GetNextTask() should run fast We do this by storing the tasks in a clever way 3

4 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Stack and Queue 4

5 Stack Last in, first out (LIFO) Supports three constant-time operations Push(x): inserts x into the stack Pop(): removes the newest item Top(): returns the newest item Very easy to implement using an array Stack and Queue 5

6 Stack Implementation Have a large enough array s[] and a counter k, which starts at zero Push(x): set s[k] = x and increment k by 1 Pop(): decrement k by 1 Top(): returns s[k - 1] (error if k is zero) C++ and Java have implementations of stack stack (C++), Stack (Java) But you should be able to implement it from scratch Stack and Queue 6

7 Queue First in, first out (FIFO) Supports three constant-time operations Enqueue(x): inserts x into the queue Dequeue(): removes the oldest item Front(): returns the oldest item Implementation is similar to that of stack Stack and Queue 7

8 Queue Implementation Assume that you know the total number of elements that enter the queue... which allows you to use an array for implementation Maintain two indices head and tail Dequeue() increments head Enqueue() increments tail Use the value of tail - head to check emptiness You can use queue (C++) and Queue (Java) Stack and Queue 8

9 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Heap and Priority Queue 9

10 Priority Queue Each element in a PQ has a priority value Three operations: Insert(x, p): inserts x into the PQ, whose priority is p RemoveTop(): removes the element with the highest priority Top(): returns the element with the highest priority All operations can be done quickly if implemented using a heap priority_queue (C++), PriorityQueue (Java) Heap and Priority Queue 10

11 Heap Complete binary tree with the heap property: The value of a node values of its children The root node has the maximum value Constant-time top() operation Inserting/removing a node can be done in O(log n) time without breaking the heap property May need rearrangement of some nodes Heap and Priority Queue 11

12 Heap Example Figure from Wikipedia Heap and Priority Queue 12

13 Indexing the Nodes Start from the root, number the nodes 1, 2,... from left to right Given a node k easy to compute the indices of its parent and children Parent node: k/2 Children: 2k, 2k + 1 Heap and Priority Queue 13

14 Inserting a Node 1. Make a new node in the last level, as far left as possible If the last level is full, make a new one 2. If the new node breaks the heap property, swap with its parent node The new node moves up the tree, which may introduce another conflict 3. Repeat 2 until all conflicts are resolved Running time = tree height = O(log n) Heap and Priority Queue 14

15 Implementation: Node Insertion Inserting a new node with value v into a heap H void InsertNode(int v) { H[++n] = v; for(int k = n; k > 1; k /= 2) { if(h[k] > H[k / 2]) swap(h[k], H[k / 2]); else break; } } Heap and Priority Queue 15

16 Deleting the Root Node 1. Remove the root, and bring the last node (rightmost node in the last level) to the root 2. If the root breaks the heap property, look at its children and swap it with the larger one Swapping can introduce another conflict 3. Repeat 2 until all conflicts are resolved Running time = O(log n) Exercise: implementation Some edge cases to consider Heap and Priority Queue 16

17 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Union-Find Structure 17

18 Union-Find Structure Used to store disjoint sets Can support two types of operations efficiently Find(x): returns the representative of the set that x belongs Union(x, y): merges two sets that contain x and y Both operations can be done in (essentially) constant time Super-short implementation! Union-Find Structure 18

19 Union-Find Structure Main idea: represent each set by a rooted tree Every node maintains a link to its parent A root node is the representative of the corresponding set Example: two sets {x, y, z} and {a, b, c, d} Union-Find Structure 19

20 Implementation Idea Find(x): follow the links from x until a node points itself This can take O(n) time but we will make it faster Union(x, y): run Find(x) and Find(y) to find corresponding root nodes and direct one to the other Union-Find Structure 20

21 Implementation We will assume that the links are stored in L[] int Find(int x) { while(x!= L[x]) x = L[x]; return x; } void Union(int x, int y) { L[Find(x)] = Find(y); } Union-Find Structure 21

22 Path Compression In a bad case, the trees can become too deep... which slows down future operations Path compression makes the trees shallower every time Find() is called We don t care how a tree looks like as long as the root stays the same After Find(x) returns the root, backtrack to x and reroute all the links to the root Union-Find Structure 22

23 Path Compression Implementations int Find(int x) { if(x == L[x]) return x; int root = Find(L[x]); L[x] = root; return root; } int Find(int x) { return x == L[x]? x : L[x] = Find(L[x]); } Union-Find Structure 23

24 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Binary Search Tree (BST) 24

25 Binary Search Tree (BST) A binary tree with the following property: for each node ðiśč, value of v values in v s left subtree value of v dvalues in v s right subtree Figure from Wikipedia Binary Search Tree (BST) 25

26 What BSTs can do Supports three operations Insert(x): inserts a node with value x Delete(x): deletes a node with value x, if there is any Find(x): returns the node with value x, if there is any Many extensions are possible Count(x): counts the number of nodes with value less than or equal to x GetNext(x): returns the smallest node with value x Binary Search Tree (BST) 26

27 BSTs in Programming Contests Simple implementation cannot guarantee efficiency In worst case, tree height becomes n (which makes BST useless) Guaranteeing O(log n) running time per operation requires balancing of the tree (hard to implement) We will skip the implementation details Use the standard library implementations set, map (C++) TreeSet, TreeMap (Java) Binary Search Tree (BST) 27

28 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Fenwick Tree 28

29 Fenwick Tree A variant of segment trees Supports very useful interval operations Set(k, x): sets the value of kth item equal to x Sum(k): computes the sum of items 1,..., k (prefix sum) Note: sum of items i,..., j = Sum(j) Sum(i 1) Both operations can be done in O(log n) time using O(n) space Fenwick Tree 29

30 Fenwick Tree Structure Full binary tree with at least n leaf nodes We will use n = 8 for our example kth leaf node stores the value of item k Each internal node stores the sum of values of its children e.g., Red node stores item[5] + item[6] Fenwick Tree 30

31 Summing Consecutive Values Main idea: choose the minimal set of nodes whose sum gives the desired value We will see that at most 1 node is chosen at each level so that the total number of nodes we look at is log 2 n and this can be done in O(log n) time Let s start with some examples Fenwick Tree 31

32 Summing: Example 1 Sum(7) = sum of the values of gold-colored nodes Fenwick Tree 32

33 Summing: Example 2 Sum(8) Fenwick Tree 33

34 Summing: Example 3 Sum(6) Fenwick Tree 34

35 Summing: Example 4 Sum(3) Fenwick Tree 35

36 Computing Prefix Sums Say we want to compute Sum(k) Maintain a pointer P which initially points at leaf k Climb the tree using the following procedure: If P is pointing to a left child of some node: Add the value of P Set P to the parent node of P s left neighbor If P has no left neighbor, terminate Otherwise: Set P to the parent node of P Use an array to implement (review the heap section) Fenwick Tree 36

37 Updating a Value Say we want to do Set(k, x) (set the value of leaf k as x) This part is a lot easier Only the values of leaf k and its ancestors change 1. Start at leaf k, change its value to x 2. Go to its parent, and recompute its value 3. Repeat 2 until the root Fenwick Tree 37

38 Extension Make the Sum() function work for any interval... not just ones that start from item 1 Can support more operations with the new Sum() function Min(i, j): Minimum element among items i,..., j Max(i, j): Maximum element among items i,..., j Fenwick Tree 38

39 Outline Stack and Queue Heap and Priority Queue Union-Find Structure Binary Search Tree (BST) Fenwick Tree Lowest Common Ancestor (LCA) Lowest Common Ancestor (LCA) 39

40 Lowest Common Ancestor (LCA) Input: a rooted tree and a bunch of node pairs Output: lowest (deepest) common ancestors of the given pairs of nodes Goal: preprocessing the tree in O(n log n) time in order to answer each LCA query in O(log n) time Lowest Common Ancestor (LCA) 40

41 Preprocessing Each node stores its depth, as well as the links to every 2 k th ancestor O(log n) additional storage per node We will use Anc[x][k] to denote the 2 k th ancestor of node x Computing Anc[x][k]: Anc[x][0] = x s parent Anc[x][k] = Anc[ Anc[x][k-1] ][ k-1 ] Lowest Common Ancestor (LCA) 41

42 Answering a Query Given two node indices x and y Without loss of generality, assume depth(x) depth(y) Maintain two pointers p and q, initially pointing at x and y If depth(p) < depth(q), bring q to the same depth as p using Anc that we computed before Now we will assume that depth(p) = depth(q) Lowest Common Ancestor (LCA) 42

43 Answering a Query If p and q are the same, return p Otherwise, initialize k as log 2 n and repeat: If k is 0, return p s parent node If Anc[p][k] is undefined, or if Anc[p][k] and Anc[q][k] point to the same node: Decrease k by 1 Otherwise: Set p = Anc[p][k] and q = Anc[q][k] to bring p and q up by 2 k levels Lowest Common Ancestor (LCA) 43

44 Conclusion We covered LOTS of stuff today Try many small examples with pencil and paper to completely internalize the material Review and solve relevant problems Discussion and collaboration are strongly recommended! Lowest Common Ancestor (LCA) 44

### 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

### 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)

### 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

### 6 March 2007 1. Array Implementation of Binary Trees

Heaps CSE 0 Winter 00 March 00 1 Array Implementation of Binary Trees Each node v is stored at index i defined as follows: If v is the root, i = 1 The left child of v is in position i The right child of

### 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

### 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

### Binary Heaps. CSE 373 Data Structures

Binary Heaps CSE Data Structures Readings Chapter Section. Binary Heaps BST implementation of a Priority Queue Worst case (degenerate tree) FindMin, DeleteMin and Insert (k) are all O(n) Best case (completely

### 1/1 7/4 2/2 12/7 10/30 12/25

Binary Heaps A binary heap is dened to be a binary tree with a key in each node such that: 1. All leaves are on, at most, two adjacent levels. 2. All leaves on the lowest level occur to the left, and all

### 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)

### Why Use Binary Trees?

Binary Search Trees Why Use Binary Trees? Searches are an important application. What other searches have we considered? brute force search (with array or linked list) O(N) binarysearch with a pre-sorted

### 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:

### Sorting revisited. Build the binary search tree: O(n^2) Traverse the binary tree: O(n) Total: O(n^2) + O(n) = O(n^2)

Sorting revisited How did we use a binary search tree to sort an array of elements? Tree Sort Algorithm Given: An array of elements to sort 1. Build a binary search tree out of the elements 2. Traverse

### 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 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

### 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

### 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

### Lecture 6: Binary Search Trees CSCI 700 - Algorithms I. Andrew Rosenberg

Lecture 6: Binary Search Trees CSCI 700 - Algorithms I Andrew Rosenberg Last Time Linear Time Sorting Counting Sort Radix Sort Bucket Sort Today Binary Search Trees Data Structures Data structure is a

### 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

### 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

### 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

### Algorithms and Data Structures Written Exam Proposed SOLUTION

Algorithms and Data Structures Written Exam Proposed SOLUTION 2005-01-07 from 09:00 to 13:00 Allowed tools: A standard calculator. Grading criteria: You can get at most 30 points. For an E, 15 points are

### 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

### 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

### 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

### Algorithms and Data Structures

Algorithms and Data Structures CMPSC 465 LECTURES 20-21 Priority Queues and Binary Heaps Adam Smith S. Raskhodnikova and A. Smith. Based on slides by C. Leiserson and E. Demaine. 1 Trees Rooted Tree: collection

### Binary Search Trees. Ric Glassey glassey@kth.se

Binary Search Trees Ric Glassey glassey@kth.se Outline Binary Search Trees Aim: Demonstrate how a BST can maintain order and fast performance relative to its height Properties Operations Min/Max Search

### 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

### 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

### Output: 12 18 30 72 90 87. struct treenode{ int data; struct treenode *left, *right; } struct treenode *tree_ptr;

50 20 70 10 30 69 90 14 35 68 85 98 16 22 60 34 (c) Execute the algorithm shown below using the tree shown above. Show the exact output produced by the algorithm. Assume that the initial call is: prob3(root)

### 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

### CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis. Linda Shapiro Winter 2015

CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis Linda Shapiro Today Registration should be done. Homework 1 due 11:59 pm next Wednesday, January 14 Review math essential

### Analysis of Algorithms I: Optimal Binary Search Trees

Analysis of Algorithms I: Optimal Binary Search Trees Xi Chen Columbia University Given a set of n keys K = {k 1,..., k n } in sorted order: k 1 < k 2 < < k n we wish to build an optimal binary search

### CHAPTER 4 ESSENTIAL DATA STRUCTRURES

CHAPTER 4 ESSENTIAL DATA STRUCTURES 72 CHAPTER 4 ESSENTIAL DATA STRUCTRURES In every algorithm, there is a need to store data. Ranging from storing a single value in a single variable, to more complex

### Union-find with deletions

19 Union-find with deletions Haim Kaplan * Nira Shafrir Robert E. Tarjan ~ Abstract In the classical union-find problem we maintain a partition of a universe of n elements into disjoint sets subject to

### Binary Coded Web Access Pattern Tree in Education Domain

Binary Coded Web Access Pattern Tree in Education Domain C. Gomathi P.G. Department of Computer Science Kongu Arts and Science College Erode-638-107, Tamil Nadu, India E-mail: kc.gomathi@gmail.com M. Moorthi

### Binary Search Trees 3/20/14

Binary Search Trees 3/0/4 Presentation for use ith the textbook Data Structures and Algorithms in Java, th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldasser, Wiley, 04 Binary Search Trees 4

### System Software Prof. Dr. H. Mössenböck

System Software Prof. Dr. H. Mössenböck 1. Memory Management 2. Garbage Collection 3. Linkers and Loaders 4. Debuggers 5. Text Editors Marks obtained by end-term exam http://ssw.jku.at/misc/ssw/ 1. Memory

### R-trees. R-Trees: A Dynamic Index Structure For Spatial Searching. R-Tree. Invariants

R-Trees: A Dynamic Index Structure For Spatial Searching A. Guttman R-trees Generalization of B+-trees to higher dimensions Disk-based index structure Occupancy guarantee Multiple search paths Insertions

### Space-Efficient Finger Search on Degree-Balanced Search Trees

Space-Efficient Finger Search on Degree-Balanced Search Trees Guy E. Blelloch Bruce M. Maggs Shan Leung Maverick Woo Computer Science Department, Carnegie Mellon University, Pittsburgh, PA 113 {guyb,bmm,maverick}@cs.cmu.edu

### Union-Find Algorithms. network connectivity quick find quick union improvements applications

Union-Find Algorithms network connectivity quick find quick union improvements applications 1 Subtext of today s lecture (and this course) Steps to developing a usable algorithm. Define the problem. Find

### Lecture 2 February 12, 2003

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.

### Data Structure with C

Subject: Data Structure with C Topic : Tree Tree A tree is a set of nodes that either:is empty or has a designated node, called the root, from which hierarchically descend zero or more subtrees, which

### INTERNATIONAL JOURNAL OF PURE AND APPLIED RESEARCH IN ENGINEERING AND TECHNOLOGY

INTERNATIONAL JOURNAL OF PURE AND APPLIED RESEARCH IN ENGINEERING AND TECHNOLOGY A PATH FOR HORIZING YOUR INNOVATIVE WORK A REVIEW ON THE USAGE OF OLD AND NEW DATA STRUCTURE ARRAYS, LINKED LIST, STACK,

### Home Page. Data Structures. Title Page. Page 1 of 24. Go Back. Full Screen. Close. Quit

Data Structures Page 1 of 24 A.1. Arrays (Vectors) n-element vector start address + ielementsize 0 +1 +2 +3 +4... +n-1 start address continuous memory block static, if size is known at compile time dynamic,

### DNS LOOKUP SYSTEM DATA STRUCTURES AND ALGORITHMS PROJECT REPORT

DNS LOOKUP SYSTEM DATA STRUCTURES AND ALGORITHMS PROJECT REPORT By GROUP Avadhut Gurjar Mohsin Patel Shraddha Pandhe Page 1 Contents 1. Introduction... 3 2. DNS Recursive Query Mechanism:...5 2.1. Client

### Stacks. Stacks (and Queues) Stacks. q Stack: what is it? q ADT. q Applications. q Implementation(s) CSCU9A3 1

Stacks (and Queues) 1 Stacks Stack: what is it? ADT Applications Implementation(s) 2 CSCU9A3 1 Stacks and ueues A stack is a very important data structure in computing science. A stack is a seuence of

### Rotation Operation for Binary Search Trees Idea:

Rotation Operation for Binary Search Trees Idea: Change a few pointers at a particular place in the tree so that one subtree becomes less deep in exchange for another one becoming deeper. A sequence of

Load Balancing Backtracking, branch & bound and alpha-beta pruning: how to assign work to idle processes without much communication? Additionally for alpha-beta pruning: implementing the young-brothers-wait

### Data storage Tree indexes

Data storage Tree indexes Rasmus Pagh February 7 lecture 1 Access paths For many database queries and updates, only a small fraction of the data needs to be accessed. Extreme examples are looking or updating

### 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

### 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

### Databases and Information Systems 1 Part 3: Storage Structures and Indices

bases and Information Systems 1 Part 3: Storage Structures and Indices Prof. Dr. Stefan Böttcher Fakultät EIM, Institut für Informatik Universität Paderborn WS 2009 / 2010 Contents: - database buffer -

### GENERATING THE FIBONACCI CHAIN IN O(log n) SPACE AND O(n) TIME J. Patera

ˆ ˆŠ Œ ˆ ˆ Œ ƒ Ÿ 2002.. 33.. 7 Š 539.12.01 GENERATING THE FIBONACCI CHAIN IN O(log n) SPACE AND O(n) TIME J. Patera Department of Mathematics, Faculty of Nuclear Science and Physical Engineering, Czech

### JAWAA: Easy Web-Based Animation from CS 0 to Advanced CS Courses

JAWAA: Easy Web-Based Animation from CS 0 to Advanced CS Courses Ayonike Akingbade, Thomas Finley, Diana Jackson, Pretesh Patel, and Susan H. Rodger Department of Computer Science Duke University Durham,

### Analysis of Binary Search algorithm and Selection Sort algorithm

Analysis of Binary Search algorithm and Selection Sort algorithm In this section we shall take up two representative problems in computer science, work out the algorithms based on the best strategy to

### EECE 276 Embedded Systems

EECE 276 Embedded Systems Embedded SW Architectures Round-robin Function-queue scheduling EECE 276 Embedded Systems Embedded Software Architectures 1 Software Architecture How to do things how to arrange

### Chapter 7: Termination Detection

Chapter 7: Termination Detection Ajay Kshemkalyani and Mukesh Singhal Distributed Computing: Principles, Algorithms, and Systems Cambridge University Press A. Kshemkalyani and M. Singhal (Distributed Computing)

### Binary Search Trees > = Binary Search Trees 1. 2004 Goodrich, Tamassia

Binary Search Trees < 6 2 > = 1 4 8 9 Binary Search Trees 1 Binary Search Trees A binary search tree is a binary tree storing keyvalue entries at its internal nodes and satisfying the following property:

### 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

### Physical Data Organization

Physical Data Organization Database design using logical model of the database - appropriate level for users to focus on - user independence from implementation details Performance - other major factor

### Zabin Visram Room CS115 CS126 Searching. Binary Search

Zabin Visram Room CS115 CS126 Searching Binary Search Binary Search Sequential search is not efficient for large lists as it searches half the list, on average Another search algorithm Binary search Very

### BSc (Hons) Business Information Systems, BSc (Hons) Computer Science with Network Security. & BSc. (Hons.) Software Engineering

BSc (Hons) Business Information Systems, BSc (Hons) Computer Science with Network Security & BSc. (Hons.) Software Engineering Cohort: BIS/05/FT BCNS/05/FT BSE/05/FT Examinations for 2005-2006 / Semester

### 7.1 Our Current Model

Chapter 7 The Stack In this chapter we examine what is arguably the most important abstract data type in computer science, the stack. We will see that the stack ADT and its implementation are very simple.

### 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

### Efficient Interval Management in Microsoft SQL Server

Efficient Interval Management in Microsoft SQL Server Itzik Ben-Gan, SolidQ Last modified: August, 0 Agenda Inefficiencies of classic interval handling Solution: RI-tree by Kriegel, Pötke and Seidl of

### This lecture. Abstract data types Stacks Queues. ADTs, Stacks, Queues 1. 2004 Goodrich, Tamassia

This lecture Abstract data types Stacks Queues ADTs, Stacks, Queues 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations

### Quiz 4 Solutions EECS 211: FUNDAMENTALS OF COMPUTER PROGRAMMING II. 1 Q u i z 4 S o l u t i o n s

Quiz 4 Solutions Q1: What value does function mystery return when called with a value of 4? int mystery ( int number ) { if ( number

### Analysis of Algorithms, I

Analysis of Algorithms, I CSOR W4231.002 Eleni Drinea Computer Science Department Columbia University Thursday, February 26, 2015 Outline 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications

### THIS CHAPTER studies several important methods for sorting lists, both contiguous

Sorting 8 THIS CHAPTER studies several important methods for sorting lists, both contiguous lists and linked lists. At the same time, we shall develop further tools that help with the analysis of algorithms

### Efficiency of algorithms. Algorithms. Efficiency of algorithms. Binary search and linear search. Best, worst and average case.

Algorithms Efficiency of algorithms Computational resources: time and space Best, worst and average case performance How to compare algorithms: machine-independent measure of efficiency Growth rate Complexity

### Experimental Comparison of Set Intersection Algorithms for Inverted Indexing

ITAT 213 Proceedings, CEUR Workshop Proceedings Vol. 13, pp. 58 64 http://ceur-ws.org/vol-13, Series ISSN 1613-73, c 213 V. Boža Experimental Comparison of Set Intersection Algorithms for Inverted Indexing

### Chapter 12 File Management

Operating Systems: Internals and Design Principles Chapter 12 File Management Eighth Edition By William Stallings Files Data collections created by users The File System is one of the most important parts

### The LCA Problem Revisited

The LA Problem Revisited Michael A. Bender Martín Farach-olton SUNY Stony Brook Rutgers University May 16, 2000 Abstract We present a very simple algorithm for the Least ommon Ancestor problem. We thus

### Algorithms and Abstract Data Types

Algorithms and Abstract Data Types Informally, algorithm means is a well-defined computational procedure that takes some value, or set of values, as input and produces some other value, or set of values,

### External Sorting. Chapter 13. Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1

External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing

### OPTIMAL BINARY SEARCH TREES

OPTIMAL BINARY SEARCH TREES 1. PREPARATION BEFORE LAB DATA STRUCTURES An optimal binary search tree is a binary search tree for which the nodes are arranged on levels such that the tree cost is minimum.

### PLANET: Massively Parallel Learning of Tree Ensembles with MapReduce. Authors: B. Panda, J. S. Herbach, S. Basu, R. J. Bayardo.

PLANET: Massively Parallel Learning of Tree Ensembles with MapReduce Authors: B. Panda, J. S. Herbach, S. Basu, R. J. Bayardo. VLDB 2009 CS 422 Decision Trees: Main Components Find Best Split Choose split

### Three Effective Top-Down Clustering Algorithms for Location Database Systems

Three Effective Top-Down Clustering Algorithms for Location Database Systems Kwang-Jo Lee and Sung-Bong Yang Department of Computer Science, Yonsei University, Seoul, Republic of Korea {kjlee5435, yang}@cs.yonsei.ac.kr

### External Memory Geometric Data Structures

External Memory Geometric Data Structures Lars Arge Department of Computer Science University of Aarhus and Duke University Augues 24, 2005 1 Introduction Many modern applications store and process datasets

### Master of Sciences in Informatics Engineering Programming Paradigms 2005/2006. Final Examination. January 24 th, 2006

Master of Sciences in Informatics Engineering Programming Paradigms 2005/2006 Final Examination January 24 th, 2006 NAME: Please read all instructions carefully before start answering. The exam will be

### 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

### External Sorting. Why Sort? 2-Way Sort: Requires 3 Buffers. Chapter 13

External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing

### Caching XML Data on Mobile Web Clients

Caching XML Data on Mobile Web Clients Stefan Böttcher, Adelhard Türling University of Paderborn, Faculty 5 (Computer Science, Electrical Engineering & Mathematics) Fürstenallee 11, D-33102 Paderborn,

### CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards

CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards Course Title: TeenCoder: Java Programming Course ISBN: 978 0 9887070 2 3 Course Year: 2015 Note: Citation(s) listed may represent

Lecture 10 Union-Find The union-nd data structure is motivated by Kruskal's minimum spanning tree algorithm (Algorithm 2.6), in which we needed two operations on disjoint sets of vertices: determine whether

### Binary search algorithm

Binary search algorithm Definition Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than

### Simple Solution for a Location Service. Naming vs. Locating Entities. Forwarding Pointers (2) Forwarding Pointers (1)

Naming vs. Locating Entities Till now: resources with fixed locations (hierarchical, caching,...) Problem: some entity may change its location frequently Simple solution: record aliases for the new address

### COS 318: Operating Systems

COS 318: Operating Systems File Performance and Reliability Andy Bavier Computer Science Department Princeton University http://www.cs.princeton.edu/courses/archive/fall10/cos318/ Topics File buffer cache

### Linux Driver Devices. Why, When, Which, How?

Bertrand Mermet Sylvain Ract Linux Driver Devices. Why, When, Which, How? Since its creation in the early 1990 s Linux has been installed on millions of computers or embedded systems. These systems may

### Dispatching in Perfectly-Periodic Schedules

Dispatching in Perfectly-Periodic Schedules Zvika Brakerski, Vladimir Dreizin, Boaz Patt-Shamir Department of Electrical Engineering, Tel Aviv University, Tel Aviv 69978, Israel. Abstract In a perfectly-periodic

### Survey On: Nearest Neighbour Search With Keywords In Spatial Databases

Survey On: Nearest Neighbour Search With Keywords In Spatial Databases SayaliBorse 1, Prof. P. M. Chawan 2, Prof. VishwanathChikaraddi 3, Prof. Manish Jansari 4 P.G. Student, Dept. of Computer Engineering&

### DESIGN AND ANALYSIS OF ALGORITHMS

CPS 3 DESIGN AND ANALYSIS OF ALGORITHMS Fall 8 Instructor: Herbert Edelsbrunner Teaching Assistant: Zhiqiang Gu CPS 3 Fall Semester of 8 Table of Contents Introduction 3 I DESIGN TECHNIQUES Divide-and-Conquer

### Distributed Computing over Communication Networks: Maximal Independent Set

Distributed Computing over Communication Networks: Maximal Independent Set What is a MIS? MIS An independent set (IS) of an undirected graph is a subset U of nodes such that no two nodes in U are adjacent.

### Scalable Prefix Matching for Internet Packet Forwarding

Scalable Prefix Matching for Internet Packet Forwarding Marcel Waldvogel Computer Engineering and Networks Laboratory Institut für Technische Informatik und Kommunikationsnetze Background Internet growth

### Small independent edge dominating sets in graphs of maximum degree three

Small independent edge dominating sets in graphs of maimum degree three Grażna Zwoźniak Grazna.Zwozniak@ii.uni.wroc.pl Institute of Computer Science Wrocław Universit Small independent edge dominating

### MAC Sublayer. Abusayeed Saifullah. CS 5600 Computer Networks. These slides are adapted from Kurose and Ross

MAC Sublayer Abusayeed Saifullah CS 5600 Computer Networks These slides are adapted from Kurose and Ross Collision-Free Protocols v N Stations v Each programmed with a unique address: 0-(N-1). v Propagation

### Attacking Anonymized Social Network

Attacking Anonymized Social Network From: Wherefore Art Thou RX3579X? Anonymized Social Networks, Hidden Patterns, and Structural Steganography Presented By: Machigar Ongtang (Ongtang@cse.psu.edu ) Social

### Databases and Information Systems 2

Databases and Information Systems Storage models for XML trees in small main memory devices Long term goals: reduce memory compression (?) still query efficiently small data structures Databases and Information