1 / 14

Understanding Red-Black Trees and Skip Lists in Data Structures

This document provides a comprehensive overview of red-black trees and skip lists, focusing on their properties, operations, and advantages. Red-black trees are a type of self-balancing binary search tree that ensure O(log n) height, thereby optimizing search, insertion, and deletion operations. Key characteristics, including node color rules and rotation operations, are discussed. Additionally, skip lists are introduced as a probabilistic alternative to balanced trees, offering constant time complexity for certain operations. This overview is essential for understanding these powerful data structures in algorithm design.

draco
Télécharger la présentation

Understanding Red-Black Trees and Skip Lists in Data Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 332: Algorithms Skip Lists David Luebke 16/3/2014

  2. Administration • Hand back homework 3 • Hand back exam 1 • Go over exam David Luebke 26/3/2014

  3. Review: Red-Black Trees • Red-black trees: • Binary search trees augmented with node color • Operations designed to guarantee that the heighth = O(lg n) • We described the properties of red-black trees • We proved that these guarantee h = O(lg n) • Next: describe operations on red-black trees David Luebke 36/3/2014

  4. Review: Red-Black Properties • The red-black properties: 1. Every node is either red or black 2. Every leaf (NULL pointer) is black • Note: this means every “real” node has 2 children 3. If a node is red, both children are black • Note: can’t have 2 consecutive reds on a path 4. Every path from node to descendent leaf contains the same number of black nodes 5. The root is always black David Luebke 46/3/2014

  5. Review: RB Trees: Rotation • Our basic operation for changing tree structure is called rotation: • Preserves BST key ordering • O(1) time…just changes some pointers y x rightRotate(y) x C A y leftRotate(x) A B B C David Luebke 56/3/2014

  6. Review: Red-Black Trees: Insertion • Insertion: the basic idea • Insert x into tree, color x red • Only r-b property 3 might be violated (if p[x] red) • If so, move violation up tree until a place is found where it can be fixed • Total time will be O(lg n) David Luebke 66/3/2014

  7. rbInsert(x) treeInsert(x); x->color = RED; // Move violation of #3 up tree, maintaining #4 as invariant: while (x!=root && x->p->color == RED) if (x->p == x->p->p->left) y = x->p->p->right; if (y->color == RED) x->p->color = BLACK; y->color = BLACK; x->p->p->color = RED; x = x->p->p; else // y->color == BLACK if (x == x->p->right) x = x->p; leftRotate(x); x->p->color = BLACK; x->p->p->color = RED; rightRotate(x->p->p); else // x->p == x->p->p->right (same as above, but with “right” & “left” exchanged) Case 1 Case 2 Case 3

  8. rbInsert(x) treeInsert(x); x->color = RED; // Move violation of #3 up tree, maintaining #4 as invariant: while (x!=root && x->p->color == RED) if (x->p == x->p->p->left) y = x->p->p->right; if (y->color == RED) x->p->color = BLACK; y->color = BLACK; x->p->p->color = RED; x = x->p->p; else // y->color == BLACK if (x == x->p->right) x = x->p; leftRotate(x); x->p->color = BLACK; x->p->p->color = RED; rightRotate(x->p->p); else // x->p == x->p->p->right (same as above, but with “right” & “left” exchanged) Case 1: uncle is RED Case 2 Case 3

  9. if (y->color == RED) x->p->color = BLACK; y->color = BLACK; x->p->p->color = RED; x = x->p->p; Case 1: “uncle” is red In figures below, all ’s are equal-black-height subtrees Review: RB Insert: Case 1 new x C C case 1 A D A D y B B x           Change colors of some nodes, preserving #4: all downward paths have equal b.h. The while loop now continues with x’s grandparent as the new x David Luebke 96/3/2014

  10. if (x == x->p->right) x = x->p; leftRotate(x); // continue with case 3 code Case 2: “Uncle” is black Node x is a right child Transform to case 3 via a left-rotation B A x x     Review: RB Insert: Case 2 C C case 2 y A B y     Transform case 2 into case 3 (x is left child) with a left rotation This preserves property 4: all downward paths contain same number of black nodes David Luebke 106/3/2014

  11. x->p->color = BLACK; x->p->p->color = RED; rightRotate(x->p->p); Case 3: “Uncle” is black Node x is a left child Change colors; rotate right A x   Review: RB Insert: Case 3 C B case 3 B A y x  C      Perform some color changes and do a right rotation Again, preserves property 4: all downward paths contain same number of black nodes David Luebke 116/3/2014

  12. Red-Black Trees • Red-black trees do what they do very well • What do you think is the worst thing about red-black trees? • A: coding them up David Luebke 126/3/2014

  13. 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! David Luebke 136/3/2014

  14. So these all take O(1)time in a linked list. Can you think of a wayto do these in O(1) timein a red-black tree? Goal: make these O(lg n) time in a linked-list setting 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()? David Luebke 146/3/2014

More Related