# Symbol Tables. IE 496 Lecture 13

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Symbol Tables IE 496 Lecture 13

2 Reading for This Lecture Horowitz and Sahni, Chapter 2

3 Symbol Tables and Dictionaries A symbol table is a data structure for storing a list of items, each with a key and satellite data The data structure supports the following operations. Construct a symbol table Search for an item having a specified key Insert an item Remove a specified item Count the number of items Print the list of items Symbol tables are also called dictionaries. Note that the keys may not have an ordering

4 Additional Operations If the items can be ordered, we may support the following additional operations Sort the items. Return the maximum or minimum item. Select the k th item. Return the successor or predecessor. We may also want to join two symbol tables into one. These operation may or may not be supported by various implementations.

5 Symbol Tables with Integer Keys Consider a table whose keys are small positive integers. Assuming no duplicate keys, we can implement such a symbol table using an array. class symboltable { private: symboltable(); \\ Disable the default constructor Item** st_; \\ An array of pointers to the items const int maxkey_; \\ The maximum allowed value of a key public: symboltable (const int M); \\ Constructor ~symboltable (); \\ Destructor int getnumitems() const; Item* search (const int k) const; Item* select (int k) const; void insert (Item* it); void remove (Item* it); void sort (ostream& os); }

6 Implementation symboltable::symboltable (const int M) { maxkey_ = M; st_ = new Item* [M]; for (int i = 0; i < M; i++) { st_[i] = 0; } } void symboltable::insert(item* it) { st_[it.getkey()] = it; } void symboltable::remove(item* it) { delete st_[it.getkey()]; st_[it.getkey()] = 0; } Item* symboltable::search(const int k) const { return st_[k]; }

7 Implementation (cont.) Item* select(int k) { for (int i = 0; i < maxkey_; i++) if (st_[i]) if (k-- == 0) return st_[i]; } Item sort(ostream& os) { for (int i = 0; i < maxkey_; i++) if (st_[i]) os << *st_[i]; } int getnumitems() const { int j(0); for (int i = 0; I < maxkey_; i++) if (st_[i]) j++; return j; }

8 Arbitrary Keys Note that with arrays, most operations are constant time. What if the keys are not integers or have arbitrary value? We could still use an array or a linear linked list to store the items. However, some of the operations would become inefficient. A binary search tree (BST) is a more efficient data structure for implementing symbol tables where the keys are an arbitrary data type.

9 Binary Search Trees In a BST data structure, the keys must have an order. As with heaps, a binary search tree is a binary tree with additional structure. In a binary tree, the key value of any node is greater than or equal to the key value of all nodes in its left subtree; less than or equal to the key value of all nodes in its right subtree. For now, we will assume that all keys are unique. With this simple structure, we can implement all functions efficiently.

10 Searching in a BST Search can be implemented recursively in a fashion similar to binary search, starting with the root. If the pointer to the current node is 0, then return 0 Otherwise, compare the search key to the current node's key, if it exists. If the keys are equal, then return a pointer to the current node. If the search key is smaller, recursively search the left subtree. If the search key is larger, recursively search the right subtree. What is the running time of this operation?

11 Inserting a Node The procedure for inserting a node is similar to that for searching. As before, we will assume there is no item with an identical key already in the tree. We perform an unsuccessful search and insert the node in place of the final null pointer at the end of the search. This places it where we would expect to find it. The running time is the same as searching. Constructing a BST from a given list of elements can be done by iteratively inserting each element.

12 Finding the Minimum and Maximum Finding the minimum and maximum is a simple procedure. The minimum is the leftmost node in the tree. The maximum is the rightmost node in the tree.

13 Sorting We can easily read off the items from a BST in sorted order. This involves walking the tree in a specified order. What is it?

14 Finding the Predecessor and Successor To find the successor of a node x, think of an inorder tree walk. After visiting a given node, what is the next value to get printed out? If x has a right child, then the successor is the node with the minimum key in the right subtree (easy to find). Otherwise, the successor is the lowest ancestor of x whose left child is also an ancestor of x (why?). Note that if a node has two children, its successor cannot have a left child (why not?). Finding the predecessor works the same way.

15 Deleting a Node Deleting a node z is more complicated than other operations because the structure must be maintained. There are a number of algorithms for doing this. The most straightforward implementation considers three cases. If z has no children, then simply set the pointer to z in the parent to be 0. If z has one child, then replace z with its child. If z has two children, then delete either the predecessor or the successor and then replace z with it. Why does this work?

16 Handling duplicate Keys What happens when the tree may contain duplicate keys? To make things easier, we can always insert items with duplicate keys in the right subtree. To find all items with the same key, search for the first item and then recursively search for the same item in the right subtree. Alternatively, we could maintain a linked list of items with the same key at each node in the tree.

17 Performance of BSTs Efficiency of the basic operations depends on the depth of the tree. Consider the search operation: what is the best case? The best case is to make the same comparisons as in binary search. However, this can only happen if the root of each subtree is the median element, i.e., the tree is balanced. Fortunately, if keys are added at random, this should be the case ``on average.'' What is the worst case?

18 Selection The selection problem is that of finding the kth element in an ordered list. We need an additional data member in the node class that tracks the size of the subtree rooted at each node. With this additional data member, we can recursively search for the k th element Starting at the root, if the size of the left subtree is k-1, return a pointer to the root. If the size of the left subtree is more than \m{k-1}, recursively search for the k th element of the left subtree. Otherwise, recursively search for the k-t-1 th element of the right subtree, where t is the size of the left subtree.

19 Balancing To guard against poor performance, we would like to have a scheme for keeping the tree balanced. There are many schemes for automatically maintaining balance. We describe here a method of manually rebalancing the tree. The basic operation that we'll need is that of rotation. Rotating the tree means changing the root from the current root to one of its children.

20 Rotation To change the right child of the current root into the new root. Make the current root the left child of the new root. Make the left child of the new root the right child of the old root. Note that we can make any node the root of the BST through a sequence of rotations. To partition the list around the kth item, select the

21 Partitioning and Rebalancing To partition the list around the item, select the kth item, select the k th item and rotate it to the root. This can be implemented easily in a recursive fashion. The left and right subtrees form the desired partition. To (re)balance a BST. Partition around the middle node. Recursively balance the left and right subtrees. This operation can be called periodically. What is the running time of this operation?

22 Delete Using the partition operation, we can implement delete in a slightly different way. Partition the right subtree of the node to be deleted around its smallest element x. Make the root of the left subtree the left child of x.

23 Root Insertion and Joining Often it is useful to be able to insert a node as the root of the BST. This can be done easily by inserting it as usual and then rotating it to the root, i.e., partition around it. With root insertion, we can define a recursive method to join two BSTs. Insert the root of the first tree as the root of the second. Recursively join the pairs of left and right subtrees.

24 Randomized BSTs We used use randomization to guard against worst case behavior. The procedure for randomly inserting into a BST of size n is as follows. With probability 1/(n+1), perform root insertion. Otherwise, recursively insert into the right or left subtree, as appropriate, using the same method. One can prove mathematically that this is the same as randomly ordering the elements first. Hence, this should guard against common worst-case inputs.

25 Hash Tables A hash table is another easy and efficient implementation of a symbol table. It works with keys that are not ordered, but supports only insert delete search It is based on the concept of a hash function. Maps each possible element into a specified bucket The number of buckets is much less than the number of possible elements Each bucket can store a limited number of elements

26 Addressing Using Hashing Recall the array-based implementation of a dictionary. We allocated one memory location for each possible key. Using hashing, we can extend this method to the case where the set U of possible keys is extremely large. A hash function h takes a key and converts it into an array index (called the hash value). With a hash function, we can use a very efficient arraybased implementation to store items in the table. Note that we can no longer do sorting or selection.

27 Parameters T = total number of possible elements b = number of buckets n = number of elements in the table n/t = element density α = n/b = load factor

28 Hash Functions Collision: two elements map to the same bucket. Choosing a hash function easy to compute minimize collisions If P(f(X) = i) = 1/b over all possible elements X, then f is a uniform hash function. It is not easy to find a good hash function. It depends on the distribution of keys We may not know that ahead of time

29 Significant Bits Two obvious hash functions are to simply consider either the first or last k bits of the key. These hash functions are very fast to compute (why?). However, they are both notoriously bad hash functions, especially for strings (why?). One possible way to do better is to use the bits in the middle, though even this is not ideal.

30 Simple Hash Function Interpret each element of the set as an integer X. Take the hash function to be f(x) = X mod M. M is the number of buckets. The choice of M is critical. M should not be a power of 2 or an even number. M should be a prime number with some other nice properties (more on this later).

31 Overflow Handling Open Addressing: If the hashed address is already used, find a new one by a simple rule. Bad performance when the hash table fills up. Can end up searching the whole table. Chaining: Form a linked list of elements with the same hash value. Only compares items with same hash value. Good performance with well-distributed hash values.

32 Analysis with Chaining Insertion is constant time, as long as we don't check for duplication. Deletion is also constant time if the lists are doubly linked. Searching takes time proportional to the length of the list. Depends on how well the hash function performs and the load factor. Both search hits and misses take time O(α).

33 Related Results Under reasonable assumptions on the distribution of keys, we can derive some probabilistic results. The probability that a given list has more than tα items on it is less than (α e / t) e -α. In other words, if the load factor is 20, the probability of a list with more than 40 items on it is The average number of items inserted before the first collision occurs is approximately the square root of M. The average number of items to be inserted before every list has at least one item is approximately M ln M.

34 Table Size with Chaining Choosing the size of the table is a perfect example of a time-space tradeoff. The bigger the table is, the more efficient it will be. On the other hand, bigger tables also mean more wasted space. When using chaining, we can afford to have a load factor greater than one. A load factor as high as 5 or 10 can work well if memory is limited.

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

### Binary Search Trees (continued)

Binary Search Trees (continued) Remove: Starting at the root, search for the value to be remove. If we reach an empty tree, the value is not in the tree. Otherwise, at some point the value is the root

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

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

### Converting a Number from Decimal to Binary

Converting a Number from Decimal to Binary Convert nonnegative integer in decimal format (base 10) into equivalent binary number (base 2) Rightmost bit of x Remainder of x after division by two Recursive

### Hashing. CS 127 Fall Data structures, so far. New data structure: Hash table. Definitions

CS 127 Fall 2003 Hashing November 12 and 17, 2003 Data structures, so far Linked lists: refer to element starting from the head of the list Arrays: refer to element by its numerical position in the memory

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

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

### Binary Trees and Binary Search Trees C++ Implementations

Binary Trees and Binary Search Trees C++ Implementations Learning Goals: Apply basic tree definitions to classification problems. Describe the properties of binary trees, binary search trees, and more

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

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

### CSCI Trees. Mark Redekopp David Kempe

1 CSCI 104 2-3 Trees Mark Redekopp David Kempe 2 Properties, Insertion and Removal BINARY SEARCH TREES 3 Binary Search Tree Binary search tree = binary tree where all nodes meet the property that: All

### Lecture 6. Randomized data structures Random number generation Skip lists: ideas and implementation Skip list time costs. Reading:

Lecture 6 Randomized data structures Random number generation Skip lists: ideas and implementation Skip list time costs Reading: Skip Lists: A Probabilistic Alternative to Balanced Trees (author William

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

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

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

### Hash Tables. Dr. Aiman Hanna Department of Computer Science & Software Engineering Concordia University, Montreal, Canada

Hash Tables Dr. Aiman Hanna Department of Computer Science & Software Engineering Concordia University, Montreal, Canada These slides has been extracted, modified and updated from original slides of :

### Searching & Sorting. Searching & Sorting 1

Searching & Sorting Searching & Sorting 1 The Plan Searching Sorting Java Context Searching & Sorting 2 Search (Retrieval) Looking it up One of most fundamental operations Without computer Indexes Tables

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

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

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

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

### CS174 Lecture 3 John Canny

CS174 Lecture 3 John Canny Randomized Quicksort and BSTs A couple more needed results about permutations: Q1: What s the probability that 4 comes before 5 in a random permutation? Tempting to say 1/2,

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

### Data Structures Using C++ 2E. Chapter 11 Binary Trees and B-Trees

Data Structures Using C++ 2E Chapter 11 Binary Trees and B-Trees Binary Trees Definition: a binary tree, T, is either empty or such that T has a special node called the root node T has two sets of nodes,

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

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

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

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

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

### Ordered Lists and Binary Trees

Data Structures and Algorithms Ordered Lists and Binary Trees Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/62 6-0:

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

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

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

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

### Hash Tables. Computer Science E-119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Data Dictionary Revisited

Hash Tables Computer Science E-119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Data Dictionary Revisited We ve considered several data structures that allow us to store and search for data

### DATA STRUCTURES USING C

DATA STRUCTURES USING C QUESTION BANK UNIT I 1. Define data. 2. Define Entity. 3. Define information. 4. Define Array. 5. Define data structure. 6. Give any two applications of data structures. 7. Give

### CS2 Final Study Guide

CS2 Final Study Guide - Know how to write an assignment operator, copy constructor and destructor for a simple class that has dynamically allocated memory. Trees 1. Define the following terms o binary

### Trees. Tree Definitions: Let T = (V, E, r) be a tree. The size of a tree denotes the number of nodes of the tree.

Trees After lists (including stacks and queues) and hash tables, trees represent one of the most widely used data structures. On one hand trees can be used to represent objects that are recursive in nature

### Dictionaries and Hash Tables

Dictionaries and Hash Tables 0 1 2 3 025-612-0001 981-101-0002 4 451-229-0004 Dictionaries and Hash Tables 1 Dictionary ADT ( 8.1.1) The dictionary ADT models a searchable collection of keyelement items

### Lecture: #9-10. Binary Trees

Lecture: #9-10 Binary Trees Topics 1. Definition and Application of Binary Trees 2. Binary Search Tree Operations 3. Template Considerations for Binary Search Trees 19-2 1. Definition and Application of

### add, push get, contains, put remove, pop ! Want O(1) operations but with general " E.g., look up employee records by social security #

Collection implementations Lecture 9: Hash tables Unsorted sets & maps Resizable arrays (array) Sorted sets Sorted maps (search tree) Stacks Queues (array) Priority queues (tree, heap) add, push O(1) O(lg

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

### Data Structures. Topic #9

Data Structures Topic #9 Today s Agenda Continue Discussing Trees Examine the algorithm to insert Examine the algorithm to remove Begin discussing efficiency of tree Are there any alternatives? 2-3 2-3-4

### The ADT Binary Search Tree. Recursive Tree Traversals. The ADT Binary Search Tree. The ADT Binary Search Tree. In-order

Recursive Tree Traversals The ADT Binary Search Tree In-order private void printinorder(treenode node) { if (node!= null) { printinorder(node.getleft()); System.out.print(node.getItem() + " "); printinorder(node.getright());

### Class 28: Binary Search Trees. Binary Search Trees

Introduction to Computation and Problem Solving Class 2: Binary Search Trees Prof. Steven R. Lerman and Dr. V. Judson Harward Binary Search Trees In the previous lecture, we defined the concept of binary

### Data Structures. Topic #8

Data Structures Topic #8 Today s Agenda Continue Discussing Table Abstractions But, this time, let s talk about them in terms of new non-linear data structures trees which require that our data be organized

### CS 3410 Ch 19 Binary Search Trees

CS 3410 Ch 19 Binary Search Trees Sections 19.1, 19.3-19.6 Pages 687-697, 702-737 Exercises 19 The find operation for a linked list is ( ), which can be prohibitive with a large amount of data. In this

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

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

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

Sorting Algorithms 1 Sorting methods Comparison based sorting On 2 ) methods E.g., Insertion, bubble Average time On log n) methods E.g., quick sort On logn) methods E.g., Merge sort, heap sort on-comparison

### School of Informatics, University of Edinburgh Computer Science 1 Ah [03 04]

School of Informatics, University of Edinburgh Computer Science 1 Ah [03 04] CS1Ah Lecture Note 25 Binary Search Trees This lecture studies binary trees in more detail, in particular their application

### Motivating Quotation

Data Structures 1 Motivating Quotation Every program depends on algorithms and data structures, but few programs depend on the invention of brand new ones. -- Kernighan & Pike 2 Programming in the Large

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

### Binary Search Trees and Hash Tables

CHAPTER 7 Binary Search Trees and Hash Tables 7.1 Binary Search Trees In Chapter, we introduced containers called a priority queues and dictionaries. A priority queue is a dispenser in which the current

### B-Trees. Algorithms and data structures for external memory as opposed to the main memory B-Trees. B -trees

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:

### 7.1 Introduction. CSci 335 Software Design and Analysis III Chapter 7 Sorting. Prof. Stewart Weiss

Chapter 7 Sorting 7.1 Introduction Insertion sort is the sorting algorithm that splits an array into a sorted and an unsorted region, and repeatedly picks the lowest index element of the unsorted region

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

### Lecture 6: Binary Search Trees CSCI Algorithms I

Lecture 6: Binary Search Trees CSCI 700 - Algorithms I Andrew Rosenberg September 24, 2009 Last Time Linear Time Sorting Counting Sort Radix Sort Bucket Sort Today Some C++ review Binary Search Trees Homework

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

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

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

### Midterm. CSE 326: Data Structures Lecture #10 Hashing I. Implementations So Far. Dictionary & Search ADTs. Hash Tables: Basic Idea

CSE : Data Structures Lecture # Hashing I Henry Kautz Winter Midterm Friday February th Will cover everything through hash tables Weiss Chapters minutes, in class You may bring one page of notes to refer

Universidad Carlos III de Madrid Algorithms and Data Structures (ADS) Bachelor in Informatics Engineering Computer Science Department Binary Search Trees. Authors: Julian Moreno Schneider Isabel Segura-Bedmar

### Exam study sheet for CS2711. List of topics

Exam study sheet for CS2711 Here is the list of topics you need to know for the final exam. For each data structure listed below, make sure you can do the following: 1. Give an example of this data structure

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

### 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 Search Trees. Yes! So, a binary tree T is a binary search tree if T is a single node.

Which are Binary Search Trees (BST)? Binary Search Trees So, a binary tree T is a binary search tree if T is a single node. Yes! No! All the values on the left subtree must be less than the value at the

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

### Chapter 4 Index Structures

Chapter 4 Index Structures Having seen the options available for representing records, we must now consider how whole relations, or the extents of classes, are represented. It is not sufficient 4.1. INDEXES

### Lecture 3. Reading: Weiss Ch 4, sections 1-4 CSE 100, UCSD: LEC 3. Page 1 of 22

Lecture 3 Binary search trees Toward a binary search tree implementation using C++ templates C++ iterators and the binary search tree successor function Reading: Weiss Ch 4, sections 1-4 Page 1 of 22 Binary

### Data Structures and Algorithms

Data Structures and Algorithms CS245-2016S-06 Binary Search Trees David Galles Department of Computer Science University of San Francisco 06-0: Ordered List ADT Operations: Insert an element in the list

### Assignment 3 (concept) Solutions

CS10b Data Structures and Algorithms Assignment 3 (concept) Solutions Due: Friday, February 18th 1. (0%) Consider the following algorithm: Algorithm Power(x, n) Input: A number x and integer n 0 Output:

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

### CS 253: Algorithms. Chapter 12. Binary Search Trees. * Deletion and Problems. Credit: Dr. George Bebis

CS 2: Algorithms Chapter Binary Search Trees * Deletion and Problems Credit: Dr. George Bebis Binary Search Trees Tree representation: A linked data structure in which each node is an object Node representation:

### Analysis of a Search Algorithm

CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,

### Practice Problems (Midterm)

ECE-250 Algorithms and Data Structures (Winter 2012) Practice Problems (Midterm) Disclaimer: Please do keep in mind that this problem set does not reflect the exact topics or the fractions of each of the

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

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

### Table Implementations. Search Add Remove. Sorted O(log n) O(n) O(n) array-based. array-based Balanced Search Trees. O(log n) O(log n) O(log n)

CS200: Hash Tables Walls & Mirrors Chapter 13 Table Implementations Search Add Remove Sorted O(log n) O(n) O(n) array-based Unsorted O(n) O(1) O(n) array-based Balanced Search Trees O(log n) O(log n) O(log

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

### Balanced Binary Search Tree

AVL Trees / Slide 1 Balanced Binary Search Tree Worst case height of binary search tree: N-1 Insertion, deletion can be O(N) in the worst case We want a tree with small height Height of a binary tree with

### UNIVERSITI MALAYSIA SARAWAK KOTA SAMARAHAN SARAWAK PSD2023 ALGORITHM & DATA STRUCTURE

STUDENT IDENTIFICATION NO UNIVERSITI MALAYSIA SARAWAK 94300 KOTA SAMARAHAN SARAWAK FAKULTI SAINS KOMPUTER & TEKNOLOGI MAKLUMAT (Faculty of Computer Science & Information Technology) Diploma in Multimedia

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

### 12 Abstract Data Types

12 Abstract Data Types 12.1 Source: Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT).

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

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

### Dictionary based on arrays. Hashing and Hash tables. Trade-offs. Hashing: Generalizing the index

Dictionary based on arrays Hashing and Hash tables Suppose have a dictionary with small integer keys, in range -. Can use an array containing values, with key as index. private Object[] thedictionary =

### Lecture Notes on Binary Search Trees

Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning Lecture 17 March 17, 2010 1 Introduction In the previous two lectures we have seen how to exploit the structure

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

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

### Trees LOGO STYLE GUIDE Schools within the University 1 19

Trees 1 Example Tree 2 A Generic Tree 3 Tree ADT n Tree definition q A tree is a set of nodes which may be empty q If not empty, then there is a distinguished node r, called root and zero or more non-empty

### Topic 15. The Binary Search Tree ADT

Topic 15 The Binary Search Tree ADT Binary Search Tree A binary search tree (BST) is a binary tree with an ordering property of its elements, such that the data in any internal node is Greater than the

### From Last Time: Remove (Delete) Operation

CSE 32 Lecture : More on Search Trees Today s Topics: Lazy Operations Run Time Analysis of Binary Search Tree Operations Balanced Search Trees AVL Trees and Rotations Covered in Chapter of the text From

### Binary Search Trees. basic implementations randomized BSTs deletion in BSTs

Binary Search Trees basic implementations randomized BSTs deletion in BSTs eferences: Algorithms in Java, Chapter 12 Intro to Programming, Section 4.4 http://www.cs.princeton.edu/introalgsds/43bst 1 Elementary

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

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