DOCSLIB.ORG

Scheme of Course Work

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

SCHEME OF COURSE WORK Course Details: Course Title Advanced Data Structures (Professional Elective – I) Course Code 15CT1111 L T P C :3 0 0 3 Program: B.Tech. Specialization: Information Technology Semester IV Prerequisites None Courses to which it is a prerequisite None Course Outcomes (COs): 1 Apply concepts of Heaps. 2 Use Hash functions in indexing. 3 Design applications using Red-Black and Splay trees. 4 Explain Digital Search Structures. 5 Apply various String Matching Techniques. Program Outcomes (POs): A graduate of Information Technology will be able to 1 Apply the knowledge of mathematics, science, engineering fundamentals and principles of Information Technology to solve problems in different domains. 2 Analyze a problem, identify and formulate the computing requirements appropriate to its solution. 3 Design & develop software applications that meet the desired specifications within the realistic constraints to serve the needs of the society. 4 Design and conduct experiments, as well as to analyze and interpret data 5 Use appropriate techniques & tools to solve engineering problems. 6 Understand the impact of information technology on environment and the evolution and importance of green computing 7 Analyze the local and global impact of computing on individual as well as on society and incorporate the results in to engineering practice. 8 Demonstrate professional ethical practices and social responsibilities in global and societal contexts. 9 Function effectively as an individual, and as a member or leader in diverse and multidisciplinary teams. 10 Communicate effectively with the engineering community and with society at large. 11 Understand engineering and management principles and apply these to one’s own work, as a member and leader in a team, to manage projects. 12 Recognize the need for updating the knowledge in the chosen field and imbibing learning to learn skills. Course Outcomes Program Outcomes Mapping: COs PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12 CO-1 S S S S S CO-2 S S S S S CO-3 S S S S S CO-4 S S S S S CO-5 S S S S S S - Strongly correlated, M - Moderately correlated, Blank - No correlation Assessment Methods: Seminar / Mid-Test / End Exam Teaching-Learning and Evaluation Week TOPIC / CONTENTS Course Sample questions TEACHING- Assessment Outcomes LEARNING Method & STRATEGY Schedule 1 UNIT-I: Single and double ended Priority Queues, CO1 1. What is the Difference Between Lecture Mid –Test 1 Leftist Trees – Height Biased Leftist Trees, Leftist single and double ended priority Trees – Weight – Biased Leftist Trees, Binomial queues. Heaps – Cost Amortization, Definition of Binomial 2. Explain in detail about Height Heaps Biased Leftist Trees. 3. Explain in detail about Weight Biased leftist Trees. 4. Define Binomial Heaps. 2 Insertion into Binomial Heaps, Melding Two CO1 1.Write a procedure to insert an Lecture Mid –Test 1 Binomial Heaps, Deletion of Minimum Element, element into a Binomial Heap. Analysis 2. Write a procedure to meld two binomial heaps. 3. Write an algorithm to delete smallest element from heap. 3 Fibonacci Heaps- Definition, Deletion from an F- CO1 1.Prove that if we start with empty F- Lecture Mid –Test 1 Heap, Decrease Key, Cascading Cut, Analysis, Heaps and perform only the Application to the Shortest Paths Problem, Pairing operations insert, meld, and delete Heaps- Definition, Meld and Insert min, then all min trees in the F-heaps are binomial trees. 4 Decrease Key, Delete Min, Arbitrary Delete, CO1 1.Into an empty two pass min pairing Lecture / Mid –Test 1 Implementation Considerations, Complexity heap, insert elements with priorities 20, 10, 5, 18, 6, 12, 14, 9, 8 and 22(in this order). Show the min pairing heap following each insert. 5 UNIT II: Hash Functions, Division, Folding, Mid CO2 1.What is the minimum number of Lecture / Mid –Test 1 Square Function, Extraction, Radix Transformation, keys that are hashed to their home Collision Resolution, Open Addressing, Chaining positions using the linear probing technique? Show an example using a 5-cell array. 2. Is there any advantage to using binary search trees instead of linked lists in the separate chaining method? 6 Bucket Addressing, Deletion, Perfect Hash Functions CO2 1.In which case does Cichelli’s Lecture Mid –Test 1 – Cichelli’s Mehtod, Perfect Hash Functions – The method not guarantee to generate a FHCD Algorithm, Hash Functions for extendible files minimal perfect hash function? Seminar – Extendible Hashing 2. Apply the FHCD algorithm to the nine Muses with r=n/2=4 and then with r=2. What is the impact of the value of r on the execution of this algorithm? 7 Hash Functions for extendible files – Linear Hashing, CO2 & CO3 1.Strictly speaking, the hash function Lecture Mid –Test 1 UNIT III:Efficient Binary Search Trees: Optimal used in extendible hashing also Binary Search Trees, AVL Trees, Red – Black Trees: dynamically changes. In what sense is Seminar Definition this true? 2. Draw the transformations for the rotation types RR and RL. 3. Compare the worst-case height of a red-black tree with n nodes and that of an AVL tree with the same number of nodes. 8 Representation of Red-Black Tree, Searching a Red- CO3 1.Develop the deletion Lecture Mid –Test 1 Black Tree, Inserting into a Red-Black Tree, Joining transformations for Red-Black tree. Red-Black Trees Show that deletion from a Red – Seminar Black tree requires at most one rotation. 9 Mid-Test 1 CO1, CO2, Mid-Test 1 CO3 (Week 9) 10 Splitting a Red – Black Tree, Splay Trees, Bottom – CO3 1.Obtain a function to perform a two- Lecture / Mid –Test 2 Up Splay Trees, Top – Down Splay Trees way join on red-black trees. You may Demonstration assume the existence of functions to search, insert, delete, and perform a three-way join. What is the time complexity of your two-way join function? 2. What is the maximum height of a bottom-up splay tree that is created as the result of n insertions made into an initially empty splay tree? Give an example of a sequence of inserts that results in a splay tree of the height? 11 UNIT –IV: Digital Search Structures – Digital CO4 1.Write the binary trie functions for Lecture Mid –Test 2 Search Trees, Digital Search Trees- Definition, the search, insert, and delete Problem solving Insertion, Deletion, Binary Tries and Patricia: Binary operations. Seminar Tries, Compressed Binary Tries, Patricia 2. Write a function to delete the element with key k from a Patricia. 12 Multiway Tries, Definition, Searching a Trie, CO4 1.Draw the tire obtained for the Lecture Mid –Test 2 Sampling Strategies, Insertion into a Trie, Deletion following data: AMIOT, AVENGER, from a Trie AVRO, HEINKEL, HELLDIVER, Seminar MACCHI, MARAUDER, MUSTANG, SPITFIRE, SYKHOI sample the keys from left to right one character at a time. 13 Keys with different length, Height of Trie, Space CO4 1.Explain how a trie could be used to Lecture / required and alternative load structures, Prefix search implement a spelling checker. Mid –Test 2 and applications, Compressed Tries, Compressed Tries Seminar 14 Compressed Tries with Skip Fields, with labeled CO4 1.Write an algorithm to insert a key = Lecture / Mid –Test 2 edges, Space Required by a compressed Trie, value x into a trie in which the keys are sampled from left to right, one character at a time. 15 UNIT – V: String Matching- Exact String Matching CO5 1.Apply the Knuth-Morris-Pratt = Lecture / Mid –Test 2 – Straightforward algorithms, The Knuth – Morris – algorithm first with next and then with Pratt Algorithm, The Boyer – Moore Algorithm nextS to P=bacbaaa and T=bacbacabcbacbbbacabacbabcbbba. 16 Multiple Searches, Bit-Oriented Approach, Matching CO5 1.Consider the serch for a pattern in a Lecture Mid-Test 2 Sets of Words text when the pattern is non in the text. What is the smallest number of character comparisions in this case executed by i. Knuth-Morris-Pratt? ii. Boyer-Moore? 17 Regular Expression and Matching, Suffix Tries and CO5 1.Draw Ukkonen suffix tries for Lecture Mid-Test 2 Trees, Suffix Arrays a. aaaa d. abcd g. aaba b. aabb e. baaa h. aaab c. abba f. abaa 18 Mid-Test 2 CO3, CO4, Mid-Test 2 CO5 19/20 END EXAM.
Recommended publications
  • Lecture 04 Linear Structures Sort

    Lecture 04 Linear Structures Sort

    Algorithmics (6EAP) MTAT.03.238 Linear structures, sorting, searching, etc Jaak Vilo 2018 Fall Jaak Vilo 1 Big-Oh notation classes Class Informal Intuition Analogy f(n) ∈ ο ( g(n) ) f is dominated by g Strictly below < f(n) ∈ O( g(n) ) Bounded from above Upper bound ≤ f(n) ∈ Θ( g(n) ) Bounded from “equal to” = above and below f(n) ∈ Ω( g(n) ) Bounded from below Lower bound ≥ f(n) ∈ ω( g(n) ) f dominates g Strictly above > Conclusions • Algorithm complexity deals with the behavior in the long-term – worst case -- typical – average case -- quite hard – best case -- bogus, cheating • In practice, long-term sometimes not necessary – E.g. for sorting 20 elements, you dont need fancy algorithms… Linear, sequential, ordered, list … Memory, disk, tape etc – is an ordered sequentially addressed media. Physical ordered list ~ array • Memory /address/ – Garbage collection • Files (character/byte list/lines in text file,…) • Disk – Disk fragmentation Linear data structures: Arrays • Array • Hashed array tree • Bidirectional map • Heightmap • Bit array • Lookup table • Bit field • Matrix • Bitboard • Parallel array • Bitmap • Sorted array • Circular buffer • Sparse array • Control table • Sparse matrix • Image • Iliffe vector • Dynamic array • Variable-length array • Gap buffer Linear data structures: Lists • Doubly linked list • Array list • Xor linked list • Linked list • Zipper • Self-organizing list • Doubly connected edge • Skip list list • Unrolled linked list • Difference list • VList Lists: Array 0 1 size MAX_SIZE-1 3 6 7 5 2 L = int[MAX_SIZE]
  • Advanced Data Structures

    Advanced Data Structures

    Advanced Data Structures PETER BRASS City College of New York CAMBRIDGE UNIVERSITY PRESS Cambridge, New York, Melbourne, Madrid, Cape Town, Singapore, São Paulo Cambridge University Press The Edinburgh Building, Cambridge CB2 8RU, UK Published in the United States of America by Cambridge University Press, New York www.cambridge.org Information on this title: www.cambridge.org/9780521880374 © Peter Brass 2008 This publication is in copyright. Subject to statutory exception and to the provision of relevant collective licensing agreements, no reproduction of any part may take place without the written permission of Cambridge University Press. First published in print format 2008 ISBN-13 978-0-511-43685-7 eBook (EBL) ISBN-13 978-0-521-88037-4 hardback Cambridge University Press has no responsibility for the persistence or accuracy of urls for external or third-party internet websites referred to in this publication, and does not guarantee that any content on such websites is, or will remain, accurate or appropriate. Contents Preface page xi 1 Elementary Structures 1 1.1 Stack 1 1.2 Queue 8 1.3 Double-Ended Queue 16 1.4 Dynamical Allocation of Nodes 16 1.5 Shadow Copies of Array-Based Structures 18 2 Search Trees 23 2.1 Two Models of Search Trees 23 2.2 General Properties and Transformations 26 2.3 Height of a Search Tree 29 2.4 Basic Find, Insert, and Delete 31 2.5ReturningfromLeaftoRoot35 2.6 Dealing with Nonunique Keys 37 2.7 Queries for the Keys in an Interval 38 2.8 Building Optimal Search Trees 40 2.9 Converting Trees into Lists 47 2.10
  • Introduction to Algorithms and Data Structures

    Introduction to Algorithms and Data Structures

    Introduction to Algorithms and Data Structures Markus Bläser Saarland University Draft—Thursday 22, 2015 and forever Contents 1 Introduction 1 1.1 Binary search . .1 1.2 Machine model . .3 1.3 Asymptotic growth of functions . .5 1.4 Running time analysis . .7 1.4.1 On foot . .7 1.4.2 By solving recurrences . .8 2 Sorting 11 2.1 Selection-sort . 11 2.2 Merge sort . 13 3 More sorting procedures 16 3.1 Heap sort . 16 3.1.1 Heaps . 16 3.1.2 Establishing the Heap property . 18 3.1.3 Building a heap from scratch . 19 3.1.4 Heap sort . 20 3.2 Quick sort . 21 4 Selection problems 23 4.1 Lower bounds . 23 4.1.1 Sorting . 25 4.1.2 Minimum selection . 27 4.2 Upper bounds for selecting the median . 27 5 Elementary data structures 30 5.1 Stacks . 30 5.2 Queues . 31 5.3 Linked lists . 33 6 Binary search trees 36 6.1 Searching . 38 6.2 Minimum and maximum . 39 6.3 Successor and predecessor . 39 6.4 Insertion and deletion . 40 i ii CONTENTS 7 AVL trees 44 7.1 Bounds on the height . 45 7.2 Restoring the AVL tree property . 46 7.2.1 Rotations . 46 7.2.2 Insertion . 46 7.2.3 Deletion . 49 8 Binomial Heaps 52 8.1 Binomial trees . 52 8.2 Binomial heaps . 54 8.3 Operations . 55 8.3.1 Make heap . 55 8.3.2 Minimum . 55 8.3.3 Union . 56 8.3.4 Insert .
  • Lecture 6 — February 9, 2017 1 Wrapping up on Hashing

    Lecture 6 — February 9, 2017 1 Wrapping up on Hashing

    CS 224: Advanced Algorithms Spring 2017 Lecture 6 | February 9, 2017 Prof. Jelani Nelson Scribe: Albert Chalom 1 Wrapping up on hashing Recall from las lecture that we showed that when using hashing with chaining of n items into m C log n bins where m = Θ(n) and hash function h :[ut] ! m that if h is from log log n wise family, then no C log n linked list has size > log log n . 1.1 Using two hash functions Azar, Broder, Karlin, and Upfal '99 [1] then used two hash functions h; g :[u] ! [m] that are fully random. Then ball i is inserted in the least loaded of the 2 bins h(i); g(i), and ties are broken randomly. log log n Theorem: Max load is ≤ log 2 + O(1) with high probability. When using d instead of 2 hash log log n functions we get max load ≤ log d + O(1) with high probability. n 1.2 Breaking n into d slots n V¨ocking '03 [2] then considered breaking our n buckets into d slots, and having d hash functions n h1; h2; :::; hd that hash into their corresponding slot of size d . Then insert(i), loads i in the least loaded of the h(i) bins, and breaks tie by putting i in the left most bin. log log n This improves the performance to Max Load ≤ where 1:618 = φ2 < φ3::: ≤ 2. dφd 1.3 Survey: Mitzenmacher, Richa, Sitaraman [3] Idea: Let Bi denote the number of bins with ≥ i balls.
  • Data Structures Binary Trees and Their Balances Heaps Tries B-Trees

    Data Structures Binary Trees and Their Balances Heaps Tries B-Trees

    Data Structures Tries Separated chains ≡ just linked lists for each bucket. P [one list of size exactly l] = s(1=m)l(1 − 1=m)n−l. Since this is a Note: Strange structure due to finals topics. Will improve later. Compressing dictionary structure in a tree. General tries can grow l P based on the dictionary, and quite fast. Long paths are inefficient, binomial distribution, easily E[chain length] = (lP [len = l]) = α. Binary trees and their balances so we define compressed tries, which are tries with no non-splitting Expected maximum list length vertices. Initialization O(Σl) for uncompressed tries, O(l + Σ) for compressed (we are only making one initialization of a vertex { the X s j AVL trees P [max len(j) ≥ j) ≤ P [len(i) ≥ j] ≤ m (1=m) last one). i j i Vertices contain -1,0,+1 { difference of balances between the left and T:Assuming all l-length sequences come with uniform probability and we have a sampling of size n, E[c − trie size] = log d. j−1 the right subtree. Balance is just the maximum depth of the subtree. k Q (s − k) P = k=0 (1=m)j−1 ≤ s(s=m)j−1=j!: Analysis: prove by induction that for depth k, there are between Fk P:qd ≡ probability trie has depth d. E[c − triesize] = d d(qd − j! k P and 2 vertices in every tree. Since balance only shifts by 1, it's pretty qd+1) = d qd. simple. Calculate opposite event { trie is within depth d − 1.
  • Chapter C4: Heaps and Binomial / Fibonacci Heaps

    Chapter C4: Heaps and Binomial / Fibonacci Heaps

    Chapter C4: Heaps and Binomial / Fibonacci Heaps C4.1 Heaps A heap is the standard implementation of a priority queue. A min-heap stores values in nodes of a tree such that heap-order property: for each node, its value is smaller than or equal to its children’s So the minimum is on top. (A max-heap can be defined similarly.) The standard heap uses a binary tree. Specifically, it uses a complete binary tree, which we define here to be a binary tree where each level except the last is full, and in the last level nodes are added left to right. Here is an example: 7 24 19 25 56 68 40 29 31 58 Now, any binary tree can be stored in an array using level numbering. The root is in cell 0, cells 1 and cells 2 are for its children, cells 3 through 6 are for its grandchildren, and so on. Note that this means a nice formula: if a node is in cell x,thenitschildren are in 2x+1 and 2x+2. Such storage can be (very) wasteful for a general binary tree; but the definition of complete binary tree means the standard heap is stored in consecutive cells of the array. C4.2 Heap Operations The idea for insertion is to: Add as last leaf, then bubble up value until heap-order property re-established. Insert(v) add v as next leaf while v<parent(v) { swapElements(v,parent(v)) v=parent(v) } One uses a “hole” to reduce data movement. Here is an example of inserting the value 12: 7 7 24 19 12 19 ) 25 56 68 40 25 24 68 40 29 31 58 12 29 31 58 56 The idea for extractMin is to: Replace with value from last leaf, delete last leaf, and bubble down value until heap-order property re-established.
  • Lecture Notes of CSCI5610 Advanced Data Structures

    Lecture Notes of CSCI5610 Advanced Data Structures

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

    Problem Set 2 1 Lazy Binomial Heaps (100 Pts)

    ICS 621: Analysis of Algorithms Fall 2019 Problem Set 2 Prof. Nodari Sitchinava Due: Friday, September 20, 2019 at the start of class You may discuss the problems with your classmates, however you must write up the solutions on your own and list the names of every person with whom you discussed each problem. 1 Lazy Binomial Heaps (100 pts) Being lazy is nothing to be proud of, but occasionally it can improve the overall execution. In this exercise, we will see how delaying the work of the Union operation in the binomial heap can improve the runtime of several operations of the binomial heap. Delete and Decrease-Key operations in the lazy binomial heap will remain unchanged. To implement the new Union we will store the list of roots as a circular doubly-linked list. That is, every node in the linked list has two pointers left and right, including the head and the tail of the list, such that head:left = tail and tail:right = head: We will also maintain the number of elements stored in the heap as a field Q:n (accessible in O(1) time). Consider the following description of Union(Q1;Q2). It simply appends the root list of Q2 to the right of the root list of Q1: function Union(Q1, Q2) if Q1:head = NIL return Q2 else if Q2:head 6= NIL tail1 Q1:head:left; tail2 Q2:head:left . Pointers to the tails of Q1 and Q2 Q2:head:left tail1; tail1:right Q2:head . Link head of Q2 to the right of the tail of Q1 Q1:head:left tail2 ; tail2:right Q1:head .
  • COS 423 Lecture 6 Implicit Heaps Pairing Heaps

    COS 423 Lecture 6 Implicit Heaps Pairing Heaps

    COS 423 Lecture 6 Implicit Heaps Pairing Heaps ©Robert E. Tarjan 2011 Heap (priority queue): contains a set of items x, each with a key k(x) from a totally ordered universe, and associated information. We assume no ties in keys. Basic Operations : make-heap : Return a new, empty heap. insert (x, H): Insert x and its info into heap H. delete-min (H): Delete the item of min key from H. Additional Operations : find-min (H): Return the item of minimum key in H. meld (H1, H2): Combine item-disjoint heaps H1 and H2 into one heap, and return it. decrease -key (x, k, H): Replace the key of item x in heap H by k, which is smaller than the current key of x. delete (x, H): Delete item x from heap H. Assumption : Heaps are item-disjoint. A heap is like a dictionary but no access by key; can only retrieve the item of min key: decrease-ke y( x, k, H) and delete (x, H) are given a pointer to the location of x in heap H Applications : Priority-based scheduling and allocation Discrete event simulation Network optimization: Shortest paths, Minimum spanning trees Lower bound from sorting Can sort n numbers by doing n inserts followed by n delete-min’s . Since sorting by binary comparisons takes Ω(nlg n) comparisons, the amortized time for either insert or delete-min must be Ω(lg n). One can modify any heap implementation to reduce the amortized time for insert to O(1) → delete-min takes Ω(lg n) amortized time.
  • Part C: Data Structures Wayne Goddard, School of Computing, Clemson University, 2019

    Part C: Data Structures Wayne Goddard, School of Computing, Clemson University, 2019

    Part C: Data Structures Wayne Goddard, School of Computing, Clemson University, 2019 Data Structures 1 C1.1 Basic Collections . 1 C1.2 Stacks and Queues . 1 C1.3 Dictionary . 2 C1.4 Priority Queue . 2 Skip Lists 3 C2.1 Levels . 3 C2.2 Implementation of Insertion . 3 Binary Search Trees 5 C3.1 Binary Search Trees . 5 C3.2 Insertion and Deletion in BST . 5 C3.3 Rotations . 6 C3.4 AVL Trees . 6 Heaps and Binomial / Fibonacci Heaps 9 C4.1 Heaps . 9 C4.2 Heap Operations . 9 C4.3 Binomial Heaps . 11 C4.4 Decrease-Key and Fibonacci Heaps . 12 Hash Tables 14 C5.1 Buckets and Hash Functions . 14 C5.2 Collision Resolution . 14 C5.3 Rehashing . 15 C5.4 Other Applications of Hashing . 16 Disjoint Set Data Structure 17 C6.1 Disjoint Forests . 17 C6.2 Pointer Jumping . 18 Chapter C1: Data Structures An ADT or abstract data type defines a way of interacting with data: it specifies only how the ADT can be used and says nothing about the implementation of the structure. An ADT is conceptually more abstract than a Java interface specification or C++ list of class member function prototypes, and should be expressed in some formal language (such as mathematics). A data structure is a way of storing data that implements certain operations. When choosing a data structure for your ADT, you might consider many issues such as whether the data is static or dynamic, whether the deletion operation is important, whether the data is ordered, etc. C1.1 Basic Collections There are three basic collections.
  • Binomal Heaps and Queues Node

    Binomal Heaps and Queues Node

    EECS 311: Data Structure and Data Management Lecture 21, 22 Binomial Queues Binomial Queues & Heaps Reading: Chapter 6 (except 6.4–6.7); Chap- binomial tree structure: ter 11, Sections 2 and 4. • n is power of 2. • n = 1: binomial tree is a single Binomal Heaps and Queues node. • n =2i two 2i−1 node binomial trees, binary heaps based queues may be improv- make one a child of root of other. able. Example: 1. perform some operations faster? • One node trees: 2. binomial queue 2 . 9 • O(log n) merge. • Two node trees: 3. redundant binomial queue 2 5 • O(1) insert 9 7 • Θ(log n) delete-min, reduce-key. • Four node trees: 4. Fibonacci heaps 2 1 • O(1) insert, reduce-key 9 5 6 3 • O(log n) delete-min 7 8 • Dijkstra’s shortest paths + fi- conacci heap ⇒ Θ(n log n + m). • Eight node tree: Binomial Heaps 1 Def: a binomial heaps is a tree that satis- 6 3 2 fies 8 9 5 heap order: key at node is smaller than keys of children. 7 1 Def: a binomial queue is 1. make k into single-node queue Q′. ′ • a list of binomial heaps. 2. merge Q and Q . • for each i, at most one heap of size 2i. Runtime: merge = Θ(log n) Algorithm: delete-min Algorithm: binomial heap merge Input: Q Input: H1 and H2, two n node binomial i heaps. 1. find heap with min key ⇒ Hi, size 2 ′ • Make tree with greater root-key child of 2. remove heap Hi ⇒ Q root of other tree.
  • Page 1 Today's Goals • Mergeable Heaps – Review Binary Heaps

    Page 1 Today's Goals • Mergeable Heaps – Review Binary Heaps

    ToDay’s&Goals& • MerGeable&Heaps& – Review&Binary&Heaps& – LinkeD2lists& – Binomial&Trees& – Binomial&Heaps& • ReD2Black& h<p://recursivelyrecursive.wordpress.com/& – Prove&balance& Heaps&O’&Fun& – Look&at&insert&/&Delete& CS&140&HMC&2&Jim&Boerkoel& Binary&heap&representaPons& ExtractMax& 16&&&14&&&10&&&8&&&&&7&&&&&&9&&&&&3&&&&&2&&&&&4&&&&&1& Return&anD&remove&the&larGest&element&in&the&set& 1&&&2&&&&3&&&&4&&&&5&&&&6&&&&7&&&&8&&&&9&&&&10& 16& 16& 14& 10& 14& 10& 8& 7& 9& 3& 8& 7& 9& 3& 2& 4& 1& 2& 4& 1& ExtractMax& ExtractMax& Return&anD&remove&the&larGest&element&in&the&set& Return&anD&remove&the&larGest&element&in&the&set& ?& 1& Heapify- 14& 10& 14& 10& 8& 7& 9& 3& 8& 7& 9& 3& 2& 4& 1& 2& 4& ExtractMax& ExtractMax& Return&anD&remove&the&larGest&element&in&the&set& Return&anD&remove&the&larGest&element&in&the&set& 14& Heapify- 8& 10& 4& 7& 9& 3& 2& 1& MerGeable&Heap& Binary&heaps& A&merGeable&heap&is&any&Data&structure&that&supports&the& followinG&five&operaPons,&in&which&each&element&has&a&key:& • MakeHeap()&2&creates&anD&returns&a&new&heap&containinG&no&elements.& • Insert(H,x)&2&inserts&element&x,&whose&key&has&already&been&filleD&in,&into& heap&H.& • Minimum(H)&2&returns&a&pointer&to&the&element&in&heap&H&whose&key&is& minimum.& • Extract:Min(H)&2&Deletes&the&element&from&heap&H&whose&key&is&minimum,& returninG&a&pointer&to&the&element.& • Union(H1,-H2)-2&creates&anD&returns&a&new&heap&that&contains&all&the& elements&of&heaps&H1&anD&H2.&Heaps&H1&anD&H2&are&“DestroyeD”&by&this& operaPon.& • ALSO:&Increase2Element,&Delete& MerGeable&heaps&