Scribd Logo
Upload

Welcome to Scribd!

  • 66 views

    CS 332: Algorithms: Skip Lists Introduction To Hashing

    Uploaded by

    Anonymous niE5VQOH
    The document discusses various data structures including red-black trees, skip lists, linked lists, and hashing tables. It reviews operations like search, insert and delete for each with their associated time complexities. For red-black trees operations are O(log n) time. Skip lists provide O(log n) expected time for search and insert using multiple linked lists with probabilistic insertion. Linked lists support basic operations in O(1) time but the document discusses how to improve this to O(log n) time using skip lists. Hashing tables provide O(1) expected time for search, insert and delete by mapping keys to array indices, with the challenge of collisions when the key range is large.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd

    CS 332: Algorithms: Skip Lists Introduction To Hashing

    Uploaded by

    Anonymous niE5VQOH
    66 views13 pages
    The document discusses various data structures including red-black trees, skip lists, linked lists, and hashing tables. It reviews operations like search, insert and delete for each with their associated time complexities. For red-black trees operations are O(log n) time. Skip lists provide O(log n) expected time for search and insert using multiple linked lists with probabilistic insertion. Linked lists support basic operations in O(1) time but the document discusses how to improve this to O(log n) time using skip lists. Hashing tables provide O(1) expected time for search, insert and delete by mapping keys to array indices, with the challenge of collisions when the key range is large.

    Original Title

    lecture17.ppt

    Copyright

    © © All Rights Reserved

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses various data structures including red-black trees, skip lists, linked lists, and hashing tables. It reviews operations like search, insert and delete for each with their associated time complexities. For red-black trees operations are O(log n) time. Skip lists provide O(log n) expected time for search and insert using multiple linked lists with probabilistic insertion. Linked lists support basic operations in O(1) time but the document discusses how to improve this to O(log n) time using skip lists. Hashing tables provide O(1) expected time for search, insert and delete by mapping keys to array indices, with the challenge of collisions when the key range is large.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    66 views13 pages

    CS 332: Algorithms: Skip Lists Introduction To Hashing

    Uploaded by

    Anonymous niE5VQOH
    The document discusses various data structures including red-black trees, skip lists, linked lists, and hashing tables. It reviews operations like search, insert and delete for each with their associated time complexities. For red-black trees operations are O(log n) time. Skip lists provide O(log n) expected time for search and insert using multiple linked lists with probabilistic insertion. Linked lists support basic operations in O(1) time but the document discusses how to improve this to O(log n) time using skip lists. Hashing tables provide O(1) expected time for search, insert and delete by mapping keys to array indices, with the challenge of collisions when the key range is large.

    Copyright:

    © All Rights Reserved
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    of 13

    CS 332: Algorithms

    Skip Lists
    Introduction to Hashing

    Review: Red-Black Trees


    Red-black trees:
    Binary search trees augmented with node color
    Operations designed to guarantee that the height

    h = O(lg n)
    We described the properties of red-black trees
    We proved that these guarantee h = O(lg n)
    We described operations on red-black trees
    Only tricky operations: insert, delete
    Use rotation to restructure tree

    Review: Skip Lists


    A relatively recent data structure
    A probabilistic alternative to balanced trees
    A randomized algorithm with benefits of r-b trees
    O(lg n) expected time for Search, Insert
    O(1) time for Min, Max, Succ, Pred

    Much easier to code than r-b trees


    Fast!

    Review: Linked Lists


    Think about a linked list as a structure for dynamic

    sets. What is the running time of:


    Min() and Max()?
    Successor()?
    Delete()?
    How can we make this O(1)?
    Predecessor()?
    Search()?
    Insert()?

    These all take O(1) time


    in a doubly linked list.
    Can you think of a way
    to do these in O(1) time
    in a red-black tree?
    A: threaded red-black
    tree w/ doubly linked list
    connecting nodes in
    sorted order

    Goal: make these O(lg n) time


    in a linked-list setting
    Idea: keep several levels of linked lists, with
    high-level lists skipping some low-level items

    Skip Lists
    The basic idea:
    level 3
    level 2
    level 1

    12

    18

    29

    35

    37

    Keep a doubly-linked list of elements


    Min, max, successor, predecessor: O(1) time
    Delete is O(1) time, Insert is O(1)+Search time

    During insert, add each level-i element to level i+1

    with probability p (e.g., p = 1/2 or p = 1/4)

    Skip List Search


    To search for an element with a given key:
    Find location in top list
    Top list has O(1) elements with high probability
    Location in this list defines a range of items in next list
    Drop down a level and recurse

    O(1) time per level on average


    O(lg n) levels with high probability
    Total time: O(lg n)

    Skip List Insert


    Skip list insert: analysis
    Do a search for that key
    Insert element in bottom-level list
    With probability p, recurse to insert in next level
    Expected number of lists = 1+ p + p2 + = ???
    = 1/(1-p) = O(1) if p is constant
    Total time = Search + O(1) = O(lg n) expected

    Skip list delete: O(1)

    Skip Lists
    O(1) expected time for most operations
    O(lg n) expected time for insert
    O(n2) time worst case (Why?)
    But random, so no particular order of insertion

    evokes worst-case behavior


    O(n) expected storage requirements (Why?)
    Easy to code

    Review: Hashing Tables


    Motivation: symbol tables
    A compiler uses a symbol table to relate symbols

    to associated data
    Symbols: variable names, procedure names, etc.
    Associated data: memory location, call graph, etc.

    For a symbol table (also called a dictionary), we

    care about search, insertion, and deletion


    We typically dont care about sorted order

    Review: Hash Tables


    More formally:
    Given a table T and a record x, with key (= symbol) and

    satellite data, we need to support:


    Insert (T, x)
    Delete (T, x)
    Search(T, x)

    We want these to be fast, but dont care about sorting the

    records
    The structure we will use is a hash table
    Supports all the above in O(1) expected time!

    Hashing: Keys
    In the following discussions we will consider

    all keys to be (possibly large) natural numbers


    How can we convert floats to natural numbers
    for hashing purposes?
    How can we convert ASCII strings to natural
    numbers for hashing purposes?

    Review: Direct Addressing


    Suppose:
    The range of keys is 0..m-1
    Keys are distinct

    The idea:
    Set up an array T[0..m-1] in which
    T[i] = x
    if x T and key[x] = i
    T[i] = NULL
    otherwise
    This is called a direct-address table
    Operations take O(1) time!
    So whats the problem?

    The Problem With


    Direct Addressing
    Direct addressing works well when the range m of

    keys is relatively small


    But what if the keys are 32-bit integers?
    Problem 1: direct-address table will have

    232 entries, more than 4 billion


    Problem 2: even if memory is not an issue, the time to
    initialize the elements to NULL may be
    Solution: map keys to smaller range 0..m-1
    This mapping is called a hash function

    You might also like

    pFad - Phonifier reborn

    Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

    Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


    Alternative Proxies:

    Alternative Proxy

    pFad Proxy

    pFad v3 Proxy

    pFad v4 Proxy