Scribd Logo
Upload

Welcome to Scribd!

  • 146 views

    Eecs 281 Heaps

    Uploaded by

    Charlie Yan
    This document discusses data structures and algorithms, including trees, priority queues, and heaps. It defines trees formally and provides examples. Key terms like root, parent, child, internal and leaf nodes are introduced. Priority queues support efficient insertion and removal of the maximum item. Heaps store data in an array-like structure and guarantee each item is greater than or equal to its children. Heap operations like insertion and removal of the maximum take O(log N) time. Heapsort uses a heap to sort in O(N log N) time without extra space.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd

    Eecs 281 Heaps

    Uploaded by

    Charlie Yan
    146 views25 pages
    This document discusses data structures and algorithms, including trees, priority queues, and heaps. It defines trees formally and provides examples. Key terms like root, parent, child, internal and leaf nodes are introduced. Priority queues support efficient insertion and removal of the maximum item. Heaps store data in an array-like structure and guarantee each item is greater than or equal to its children. Heap operations like insertion and removal of the maximum take O(log N) time. Heapsort uses a heap to sort in O(N log N) time without extra space.

    Original Description:

    Heaps from Algorithms course

    Original Title

    EECS 281 HEAPS

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses data structures and algorithms, including trees, priority queues, and heaps. It defines trees formally and provides examples. Key terms like root, parent, child, internal and leaf nodes are introduced. Priority queues support efficient insertion and removal of the maximum item. Heaps store data in an array-like structure and guarantee each item is greater than or equal to its children. Heap operations like insertion and removal of the maximum take O(log N) time. Heapsort uses a heap to sort in O(N log N) time without extra space.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    146 views25 pages

    Eecs 281 Heaps

    Uploaded by

    Charlie Yan
    This document discusses data structures and algorithms, including trees, priority queues, and heaps. It defines trees formally and provides examples. Key terms like root, parent, child, internal and leaf nodes are introduced. Priority queues support efficient insertion and removal of the maximum item. Heaps store data in an array-like structure and guarantee each item is greater than or equal to its children. Heap operations like insertion and removal of the maximum take O(log N) time. Heapsort uses a heap to sort in O(N log N) time without extra space.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 25

    EECS 281: Data Structures and Algorithms

    Intro to Trees, and Priority Queues/Heaps

    Informal Definition: Tree


    Mathematical abstraction that plays a central role in the design and analysis of algorithms

    design: build and use explicit data structures that are concrete realizations of trees analysis: describe the dynamic properties of algorithms

    Formal Definition: Tree

    Tree: nonempty collection of vertices/ nodes and edges in which there exists precisely one path connecting any two nodes

    (Usually, we say graphs have vertices, and trees have nodes)

    Some Examples

    Some Tree Terminology


    In the context of FindFib(5) Root: top-most vertex in the tree
    the initial call e.g., FindFib(5)

    Parent/Child: direct links in tree


    FindFib(5) calls FindFib(4) then FindFib(3) (parent) (1st child) (2nd child)

    Internal node: a node with children


    Any call to FindFib with argument >= 2 e.g., FindFib(3), FindFib(2)

    Leaf/External node: a node without children


    Any call to FindFib(0) or FindFib(1)

    Some Tree Terminology


    Depth: depth(root) = 0; depth(node) = depth(parent)+1; Height: height(leaf) = 0; height(node) = max(height(child)) + 1; Max Height/Depth: maximum height/depth of trees nodes

    A Special Case: Binary Tree


    Defn: A binary tree is defined recursively as a data structure with either no nodes or three disjoint sets of nodes a root node, a binary tree called the left subtree, and a binary tree called the right subtree

    M-ary tree: definition above where each internal node has M children.

    Concrete Implementation
    Node in Binary Tree
    struct node {Item item; node *left, *right};

    A node contains some information, and points to its left child node and right child node Efficient for moving down a tree from parent to child Modification to move up tree from child to parent?

    Priority Queue: ADT


    Efficient insertion of new items Efficient removal of item with largest key

    Defn: a priority queue is a data structure of items with keys that supports two basic operations: insert a new item, and remove the item with the largest key

    Unsorted Array Implementation

    Insert
    increment size of array put item at the end of the array constant time: O(1)

    Remove maximum
    find the max in the array by inspecting each element exchange the maximum with the last item decrement the size of the array linear time: O(N)

    We can do better

    Heap
    Imprecise Defn: Storage of data in an array, such that each key is guaranteed to be the keys in two other specific positions and the key in one other specific position

    (tree-like properties)

    Heap-Ordered Trees, Heaps


    Defn: A tree is heap-ordered if the key in each node is the keys of all the nodes children
    Property: No node in a heap-ordered tree has a key larger than the key at the root

    Defn: A heap is a set of nodes with keys arranged in a complete heap-ordered binary tree, represented as an array

    Example

    Pop Quiz (Analysis Question)


    Given an array implementation of a heap, and the ith position in the array: 1) what is the location of is parent? 2) what is the location of is two children? assume that heaps root is in position 1, not 0

    answer to 1) answer to 2)

    Breaking and Fixing a Heap

    What if priority of item on bottom of heap is increased?


    affects items above need to bottom-up heapify

    What if priority of item on top of heap is decreased?


    affects items below need to top-down heapify

    Bottom Up Heapify
    void fixUp(Item heap[], int k) { while (k > 1 && heap[k/2] < heap[k]){ exch(heap[k], heap[k/2]); k = k/2;} }

    Pass index (k) of array element w/ increased priority Exchange the key in the given node with the key of the parent until:
    we reach the root, or we reach a parent with a larger (or equal) key

    Note root is well-known (position 1)

    Top Down Heapify


    void fixDown(Item heap[], int heapsize, int k) while (2*k <= heapsize) { int j = 2*k; if (j < heapsize && heap[j] < heap[j+1]) j++; if (heap[k] >= heap[j]) break; exch(heap[k], heap[j]); k = j; }

    Pass index (k) of array element w/ decreased priority Exchange the key in the given node with the largest key among the nodes children, moving down to that child, until:
    we reach bottom of heap there are no children with a larger key

    Unlike root, last node is not known in advance, must pass it (heapsize)

    Heap Implementation
    void insert (Item item) { pq[++N] = item; fixUp(pq,N); } Item getmax() { swap(pq[1], pq[N]); fixDown(pq, N-1, 1) return pq[N--]; }

    Insert
    put item at the end of the priority queue use fixUp to find proper position

    Remove maximum
    remove root take item from end of array and place at root use fixDown to find proper position

    Properties of insert and getmax


    Property: Insert requires no more than lg N comparisons between heap elements insert: O(lgN) Property: Find (and remove) max requires no more than 2 lg N comparisons between heap elements getmax: O(lgN)

    Intuition for Heapsort


    Repeatedly dequeue the highest priority element from a priority queue Advantages

    easily implemented as an array entire sort can be done in place

    More Detail for Heapsort

    Phase 1
    Transform unsorted array into heap
    called Heapifying

    Phase 2
    Remove the largest item from heap and add it to sorted sequence Heapify Repeat

    Phase 1: Build Heap


    void buildHeap(Item heap[], int n) { for (unsigned int i = n/2; i > 0; --i) fixDown(heap, n, i); }

    Note order of node visitation in tree What would happen if algorithm started nearer to root?

    Phase 2: Sort Heap


    void sortHeap(Item heap[], int n) { buildHeap(heap,n); for (unsigned int i = n; i >= 2; --i) { swap(heap[i], heap[1]); fixDown(heap, i-1, 1); }

    Remember first array index in heap is 1, not 0 Make call to buildHeap Loop from last item in the heap
    swap current root and current last position fix the heap

    Heapsort

    Take N elements, insert into a heap


    each takes at most O(log N) time, N of them

    Remove elements one at a time, filling original array from back to front.
    each takes at most O(log N) time, N of them

    Total running time: O(N log N)


    requires no additional space

    Summary: Heaps

    Priority queue is an ADT


    need insertion and removal

    Unsorted array
    O(1) insertion of an item O(N) removal of largest item

    Heap
    efficient O(log N) insertion of an item efficient O(log N) removal of largest item

    Must be able to maintain heap property


    bottom-up heapify top-down heapify

    Heapsort
    O(N log N) sort that takes advantage of heap properties

    You might also like