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

Save this PDF as:

Size: px
Start display at page:

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

## Transcription

1 Binary Search Trees Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 27

2 1 Properties of Binary Search Trees 2 Basic BST operations The worst-case time complexity of BST operations 4 The average-case time complexity of BST operations 5 Self-balancing binary and multiway search trees 6 Self-balancing BSTs: AVL trees 7 Self-balancing BSTs: Red-black trees 8 Balanced B-trees for external search 2 / 27

3 Binary Search Tree: Left-Right Ordering of Keys Left-to-right numerical ordering in a BST: for every node i, the values of all the keys k left:i in the left subtree are smaller than the key k i in i and the values of all the keys k right:i in the right subtree are larger than the key k i in i: {k left:i } l < k i < r {k right:i } Compare to the bottom-up ordering in a heap where the key k i of every parent node i is greater than or equal to the keys k l and k r in the left and right child node l and r, respectively: k i k l and k i k r. i : k i BST i : k i Heap {k left:i } {k right:i } l : k l r : k r / 27

4 Binary Search Tree: Left-Right Ordering of Keys BST Non-BST: Key 2 cannot be in the right subtree of key. Non-BST: Keys 11 and 12 cannot be in the left subtree of key / 27

5 Basic BST Operations BST is an explicit data structure implementing the table ADT. BST are more complex than heaps: any node may be removed, not only a root or leaves. The only practical constraint: no duplicate keys (attach them all to a single node). Basic operations: find a given search key or detect that it is absent in the BST. insert a node with a given key to the BST if it is not found. findmin: find the minimum key. findmax: find the maximum key. remove a node with a given key and restore the BST if necessary. 5 / 27

6 BST Operations Find / Insert a Node 10 8 < 10? 10 7 < 10? 8 <? 15 7 <? < 5? < 5? = < 8? Found node find: a successful binary search. 7 Inserted node insert: creating a new node at the point where an unsuccessful search stops. 6 / 27

7 BST Operations: FindMin / FindMax Extremely simple: starting at the root, branch repeatedly left (findmin) or right (findmax) as long as a corresponding child exists. The root of the tree plays a role of the pivot in quicksort and quickselect. As in quicksort, the recursive traversal of the tree can sort the items: 1 First visit the left subtree; 2 Then visit the root, and Then visit the right subtree. O(log n) average-case and O(n) worst-case running time for find, insert, findmin, and findmax operations, as well as for selecting a single item (just as in quickselect). 7 / 27

8 BST Operation: Remove a Node The most complex because the tree may be disconnected. Reattachment must retain the ordering condition. Reattachment should not needlessly increase the tree height. Standard method of removing a node i with c children: c Action 0 Simply remove the leaf i. 1 Remove the node i after linking its child to its parent node. 2 Swap the node i with the node j having the smallest key k j in the right subtree of the node i. After swapping, remove the node i (as now it has at most one right child). In spite of its asymmetry, this method cannot be really improved. 8 / 27

9 BST Operation: Remove a Node Remove 10 Replace 10 (swap with 12 and delete) Minimum key in the right subtree 9 / 27

10 Analysing BST: The Worst-case Time Complexity Lemma.11: The search, retrieval, update, insert, and remove operations in a BST all take time in O(h) in the worst case, where h is the height of the tree. Proof: The running time T (n) of these operations is proportional to the number of nodes ν visited. Find / insert: ν = 1 + the depth of the node. Remove: the depth + at most the height of the node. In each case T (n) = O(h). For a well-balanced BST, T (n) O(log n) (logarithmic time). In the worst case T (n) Θ(n) (linear time) because insertions and deletions may heavily destroy the balance. 10 / 27

11 Analysing BST: The Worst-case Time Complexity BSTs of height h log n 5 5 BSTs of height h n / 27

12 Analysing BST: The Average-case Time Complexity More balanced trees are more frequent than unbalanced ones. Definition.12: The total internal path length, S τ (n), of a binary tree τ is the sum of the depths of all its nodes. Depth S τ (8) = = 15 Average complexity of a successful search in τ: the average node depth, 1 n S 1 15 τ (n), e.g. Sτ (8) = = in this example. 8 8 Average-case complexity of searching: Averaging S τ (n) for all the trees of size n, i.e. for all possible 1 n! insertion orders, occurring with equal probability, n!. 12 / 27

13 The Θ(log n) Average-case BST Operations Let S(n) be the average of the total internal path length, S τ (n), over all BST τ created from an empty tree by sequences of n random insertions, each sequence considered as equiprobable. Lemma.1: The expected time for successful and unsuccessful search (update, retrieval, insertion, and deletion) in such BST is Θ(log n). Proof: It should be proven that S(n) Θ(n log n). Obviously, S(1) = 0. Any n-node tree, n > 1, contains a left subtree with i nodes, a root at height 0, and a right subtree with n i 1 nodes; 0 i n 1. For a fixed i, S(n) = (n 1) + S(i) + S(n i 1), as the root adds 1 to the path length of each other node. 1 / 27

14 The Θ(log n) Average-case BST Operations Proof of Lemma.1 (continued): After summing these recurrences for 0 i n 1 and averaging, just the same recurrence as for the average-case quicksort analysis is obtained: S(n) = (n 1) + 2 n n 1 i=0 S(i) Therefore, S(n) Θ(n log n), and the expected depth of a node is 1 ns(n) Θ(log n). Thus, the average-case search, update, retrieval and insertion time is in Θ(log n). It is possible to prove (but in a more complicate way) that the average-case deletion time is also in Θ(log n). The BST allow for a special balancing, which prevents the tree height from growing too much, i.e. avoids the worst cases with linear time complexity Θ(n). 14 / 27

15 Self-balanced Search Trees Balancing ensures that the total internal path lengths of the trees are close to the optimal value of n log n. The average-case and the worst-case complexity of operations is O(log n) due to the resulting balanced structure. But the insertion and removal operations take longer time on the average than for the standard binary search trees. Balanced BST: AVL trees (1962: G. M. Adelson-Velskii and E. M. Landis). Red-black trees (1972: R. Bayer) symmetric binary B-trees ; the present name and definition: 1978; L. Guibas and R. Sedgewick. AA-trees (199: A. Anderson). Balanced multiway search trees: B-trees (1972: R. Bayer and E. McCreight). 15 / 27

16 Self-balancing BSTs: AVL Trees Complete binary trees have a too rigid balance condition to be maintained when new nodes are inserted. Definition.14: An AVL tree is a BST with the following additional balance property: for any node in the tree, the height of the left and right subtrees can differ by at most 1. The height of an empty subtree is 1. Advantages of the AVL balance property: Guaranteed height Θ(log n) for an AVL tree. Less restrictive than requiring the tree to be complete. Efficient ways for restoring the balance if necessary. 16 / 27

17 Self-balancing BSTs: AVL Trees Lemma.15: The height of an AVL tree with n nodes is Θ(log n). Proof: Due to the possibly different heights of subtrees, an AVL tree of height h may contain fewer than 2 h+1 1 nodes of the complete tree. Let S h be the size of the smallest AVL tree of height h. S 0 = 1 (the root only) and S 1 = 2 (the root and one child). The smallest AVL tree of height h has the smallest subtrees of height h 1 and h 2 by the balance property, so that S h = S h 1 + S h = F h+ 1 i h F i S h where F i is the i th Fibonacci number (recall Lecture 6). 17 / 27

18 Self-balancing BSTs: AVL Trees (Proof of Lemma.15 cont.) That S h = F h+ 1 is easily proven by induction: Base case: S 0 = F 1 = 1 and S 1 = F 4 1 = 2. Hypothesis: Let S i = F i+ 1 and S i 1 = F i+2 1. Inductive step: Then S i+1 = S i + S i 1 1 = F i+ 1 } {{ } F } i+2 {{ 1 } S i S i 1 Therefore, for each AVL tree of height h and with n nodes: n S h ϕh+ 5 1 where ϕ 1.618, so that its height h 1.44 lg(n + 1) 1.. The worst-case height is at most 44% more than the minimum height for binary trees. The average-case height of an AVL tree is provably close to lg n. 18 / 27

19 Self-balancing BSTs: AVL Trees Rotation to restore the balance after BST insertions and deletions: q p p c a q a b Right rotation b c Left rotation If there is a subtree of large height below the node a, the right rotation will decrease the overall tree height. All self-balancing binary search trees use the idea of rotation. Rotations are mutually inverse and change the tree only locally. Balancing of AVL trees requires extra memory and heavy computations. More relaxed efficient BSTs, r.g., red-black trees, are used more often in practice. 19 / 27

20 Self-balancing BSTs: Red-black Trees Definition.17: A red-black tree is a BST such that Every node is coloured either red or black. Every non-leaf node has two children. The root is black. All children of a red node must be black. Every path from the root to a leaf must contain the same number of black nodes. Theorem.18: If every path from the root to a leaf contains b black nodes, then the tree contains at least 2 b 1 black nodes. 20 / 27

21 Self-balaning BSTs: Red-black Trees Proof of Theorem.18: Base case: Holds for b = 1 (either the black root only or the black root and one or two red children). Hypothesis: Let it hold for all red-black trees with b black nodes in every path. Inductive step: A tree with b + 1 black nodes in every path and two black children of the root contains two subtrees with b black nodes just under the root and has in total at least (2 b 1) = 2 b+1 1 black nodes. If the root has a red child, the latter has only black children, so that the total number of the black nodes can become even larger. 21 / 27

22 Self-balancing BSTs: Red-black and AA Trees Searching in a red-black tree is logarithmic, O(log n). Each path cannot contain two consecutive red nodes and increase more than twice after all the red nodes are inserted. Therefore, the height of a red-black tree is at most 2 lg n. No precise average-case analysis (only empirical findings or properties of red-black trees with n random keys): The average case: lg n comparisons per search. The worst case: < 2 lg n + 2 comparisons per search. O(1) rotations and O(log n) colour changes to restore the tree after inserting or deleting a single node. AA-trees: the red-black trees where the left child may not be red are even more efficient if node deletions are frequent. 22 / 27

23 Balanced B-trees The Big-Oh analysis is invalid if the assumed equal time complexity of elementary operations does not hold. External ordered databases on magnetic or optical disks. One disk access hundreds of thousands of computer instructions. The number of accesses dominates running time. Even logarithmic worst-case complexity of red-black or AA-trees is unacceptable. Each search should involve a very small number of disk accesses. Binary tree search (with an optimal height lg n) cannot solve the problem. Height of an optimal m-ary search tree (m-way branching): log m n, i.e. lg n lg m 2 / 27

24 Balanced B-trees Height of the optimal m-ary search tree with n nodes: n log 2 n log 10 n log 100 n log 1000 n Multiway search tree of order m = 4: k < 4 4; 10 4 k < k 1; 6; 8 14; 17; Data records are associated only with leaves (most of definitions). 24 / 27

25 Balanced B-trees A B-tree of order m is an m-ary search tree such that: 1 The root either is a leaf, or has µ {2,..., m} children. 2 There are µ { } m 2,..., m children of each non-leaf node, except possibly the root. µ 1 keys, (θ i : i = 1,..., µ 1), guide the search in each non-leaf node with µ children, θ i being the smallest key in subtree i All leaves at the same depth. 5 Data items are in leaves, each leaf storing λ { l 2,..., l } items, for some l. Conditions 1 : to define the memory space for each node. Conditions 4 5: to form a well-balanced tree. 25 / 27

26 Balanced B-trees B-trees are usually named by their branching limits m 2 m: e.g., 2 trees with m = or 2 4 trees with m = 4. m = 4; l = 7: 2 4 B-tree with the leaf storage size 7 (2..4 children per node and 4..7 data items per leaf) < ; < 75 < < < / 27

27 Balanced B-trees Because the nodes are at least half full, a B-tree with m 8 cannot be a simple binary or ternary tree. Simple data insertion if the corresponding leaf is not full. Otherwise, splitting a full leaf into two leaves, both having the minimum number of data items, and updating the parent node. If necessary, the splitting propagates up until finding a parent that need not be split or reaching the root. Only in the extremely rare case of splitting the root, the tree height increases, and a new root with two children (halves of the previous root) is created. Data insertion, deletion, and retrieval in the worst case: about log m n 2 disk accesses. This number is practically constant if m is sufficiently big. 27 / 27

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

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

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

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

### AVL Trees. CSE 373 Data Structures

AVL Trees CSE 373 Data Structures Readings Reading Chapter 1 Section 1.2 AVL Trees 2 Binary Search Tree - Best Time All BST operations are O(d), where d is tree depth minimum d is = log N for a binary

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

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

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

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

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

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

### A Comparison of Dictionary Implementations

A Comparison of Dictionary Implementations Mark P Neyer April 10, 2009 1 Introduction A common problem in computer science is the representation of a mapping between two sets. A mapping f : A B is a function

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

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

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

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

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

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

### CSE 326: Data Structures B-Trees and B+ Trees

Announcements (4//08) CSE 26: Data Structures B-Trees and B+ Trees Brian Curless Spring 2008 Midterm on Friday Special office hour: 4:-5: Thursday in Jaech Gallery (6 th floor of CSE building) This is

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

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

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

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

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

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

### Fundamental Algorithms

Fundamental Algorithms Chapter 6: AVL Trees Michael Bader Winter 2011/12 Chapter 6: AVL Trees, Winter 2011/12 1 Part I AVL Trees Chapter 6: AVL Trees, Winter 2011/12 2 Binary Search Trees Summary Complexity

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

### Heaps & Priority Queues in the C++ STL 2-3 Trees

Heaps & Priority Queues in the C++ STL 2-3 Trees CS 3 Data Structures and Algorithms Lecture Slides Friday, April 7, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks

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

### The Selection Problem

The Selection Problem The selection problem: given an integer k and a list x 1,..., x n of n elements find the k-th smallest element in the list Example: the 3rd smallest element of the following list

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

### TREE BASIC TERMINOLOGIES

TREE Trees are very flexible, versatile and powerful non-liner data structure that can be used to represent data items possessing hierarchical relationship between the grand father and his children and

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

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

### CSC 421: Algorithm Design Analysis. Spring 2014

CSC 421: Algorithm esign Analysis Spring 2014 Transform & conquer transform-and-conquer approach presorting balanced search trees, heaps Horner's Rule problem reduction 1 Transform & conquer the idea behind

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

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

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

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

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

### CSE Homework 1

CSE 00 - Homework.8 (a) Give a precise expression for the minimum number of nodes in an AVL tree of height h. (b) What is the minimum number of nodes in an AVL tree of height? (a) Let S(h) be the minimum

### Nearly Complete Binary Trees and Heaps

Nearly Complete Binary Trees and Heaps DEFINITIONS: i) The depth of a node p in a binary tree is the length (number of edges) of the path from the root to p. ii) The height (or depth) of a binary tree

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

### CMPS101: Homework #4 Solutions

CMPS101: Homework #4 s TA: Krishna (vrk@soe.ucsc.edu) Due Date: March 5, 2013 12.1-5 Argue that since sorting n elements takes (nlgn) time in the worst case in the comparison model, any comparison-based

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

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

### Balanced Binary Trees

Reminders about Trees Balanced Binary Trees With pictures by John Morris (ciips.ee.uwa.edu.au/~morris) A binary tree is a tree with exactly two sub-trees for each node, called the left and right sub-trees.

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

### Tree Properties (size vs height) Balanced Binary Trees

Tree Properties (size vs height) Balanced Binary Trees Due now: WA 7 (This is the end of the grace period). Note that a grace period takes the place of a late day. Now is the last time you can turn this

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

### CS 253: Algorithms. Chapter 8. Sorting in Linear Time. Credit: Dr. George Bebis

CS 5: Algorithms Chapter 8 Sorting in Linear Time Credit: Dr. George Bebis How Fast Can We Sort? How Fast Can We Sort? Insertion sort: O(n ) Bubble Sort, Selection Sort: (n ) Merge sort: (nlgn) Quicksort:

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

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

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

### In our lecture about Binary Search Trees (BST) we have seen that the operations of searching for and inserting an element in a BST can be of the

In our lecture about Binary Search Trees (BST) we have seen that the operations of searching for and inserting an element in a BST can be of the order O(log n) (in the best case) and of the order O(n)

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

### 4.4 The recursion-tree method

4.4 The recursion-tree method Let us see how a recursion tree would provide a good guess for the recurrence = 3 4 ) Start by nding an upper bound Floors and ceilings usually do not matter when solving

### Comparing Leaf and Root Insertion

30 Research Article SACJ, No. 44., December 2009 Comparing Leaf Root Insertion Jaco Geldenhuys, Brink van der Merwe Computer Science Division, Department of Mathematical Sciences, Stellenbosch University,

### Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort).

Chapter 7: Quicksort Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort). The three steps of Quicksort are as follows:

### Comparison Sort. - In Merge Sort, the merge procedure chooses an item from one of two arrays after comparing the top items from both arrays.

Comparison Sort A Comparison Sort is a sorting algorithm where the final order is determined only by comparisons between the input elements. - In Insertion Sort, the proper position to insert the current

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

### 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 7. Multiway Trees. Data Structures and Algorithms in Java

Chapter 7 Multiway Trees Data Structures and Algorithms in Java Objectives Discuss the following topics: The Family of B-Trees Tries Case Study: Spell Checker Data Structures and Algorithms in Java 2 Multiway

### CMPS 102 Solutions to Homework 1

CMPS 0 Solutions to Homework Lindsay Brown, lbrown@soe.ucsc.edu September 9, 005 Problem..- p. 3 For inputs of size n insertion sort runs in 8n steps, while merge sort runs in 64n lg n steps. For which

### CSC148 Lecture 8. Algorithm Analysis Binary Search Sorting

CSC148 Lecture 8 Algorithm Analysis Binary Search Sorting Algorithm Analysis Recall definition of Big Oh: We say a function f(n) is O(g(n)) if there exists positive constants c,b such that f(n)

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

### - Easy to insert & delete in O(1) time - Don t need to estimate total memory needed. - Hard to search in less than O(n) time

Skip Lists CMSC 420 Linked Lists Benefits & Drawbacks Benefits: - Easy to insert & delete in O(1) time - Don t need to estimate total memory needed Drawbacks: - Hard to search in less than O(n) time (binary

### B-trees. Andreas Kaltenbrunner, Lefteris Kellis & Dani Martí. B-trees, A. Kaltenbrunner, L. Kellis & D. Martí 1

B-trees Andreas Kaltenbrunner, Lefteris Kellis & Dani Martí B-trees, A. Kaltenbrunner, L. Kellis & D. Martí 1 What are B-trees? B-trees are balanced search trees: height = O ( log(n) ) for the worst case.

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

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

### M-way Trees and B-Trees

Carlos Moreno cmoreno @ uwaterloo.ca EIT-4103 https://ece.uwaterloo.ca/~cmoreno/ece250 Standard reminder to set phones to silent/vibrate mode, please! Once upon a time... in a course that we all like to

### Data Structures Fibonacci Heaps, Amortized Analysis

Chapter 4 Data Structures Fibonacci Heaps, Amortized Analysis Algorithm Theory WS 2012/13 Fabian Kuhn Fibonacci Heaps Lacy merge variant of binomial heaps: Do not merge trees as long as possible Structure:

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

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

### Lecture Note 05 EECS 4101/5101 Instructor: Andy Mirzaian. SKEW HEAPS: Self-Adjusting Heaps

Lecture Note 05 EECS 40/50 Instructor: Andy Mirzaian SKEW HEAPS: Self-Adjusting Heaps In this handout we describe the skew heap data structure, a self-adjusting form of heap related to the leftist heap

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

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

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

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

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

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

### 1. What s wrong with the following proofs by induction?

ArsDigita University Month : Discrete Mathematics - Professor Shai Simonson Problem Set 4 Induction and Recurrence Equations Thanks to Jeffrey Radcliffe and Joe Rizzo for many of the solutions. Pasted

### The Goldberg Rao Algorithm for the Maximum Flow Problem

The Goldberg Rao Algorithm for the Maximum Flow Problem COS 528 class notes October 18, 2006 Scribe: Dávid Papp Main idea: use of the blocking flow paradigm to achieve essentially O(min{m 2/3, n 1/2 }

### Lecture 1: Course overview, circuits, and formulas

Lecture 1: Course overview, circuits, and formulas Topics in Complexity Theory and Pseudorandomness (Spring 2013) Rutgers University Swastik Kopparty Scribes: John Kim, Ben Lund 1 Course Information Swastik

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

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

### Query Processing, optimization, and indexing techniques

Query Processing, optimization, and indexing techniques What s s this tutorial about? From here: SELECT C.name AS Course, count(s.students) AS Cnt FROM courses C, subscription S WHERE C.lecturer = Calders

### Divide and Conquer. Textbook Reading Chapters 4, 7 & 33.4

Divide d Conquer Textook Reading Chapters 4, 7 & 33.4 Overview Design principle Divide d conquer Proof technique Induction, induction, induction Analysis technique Recurrence relations Prolems Sorting

### CS 210 Algorithms and Data Structures College of Information Technology and Engineering Weisberg Division of Engineering and Computer Science

CS 210 Algorithms and Data Structures College of Information Technology and Engineering Weisberg Division of Engineering and Computer Science Semester and Year: Spring 2009 Classroom Section, Meeting Times,

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

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

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