Open In App

Skip List | Set 3 (Searching and Deletion)

Last Updated : 19 Apr, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

In previous article Skip List | Set 2 (Insertion) we discussed the structure of skip nodes and how to insert an element in the skip list. In this article we will discuss how to search and delete an element from skip list.

Searching an element in Skip list

Searching an element is very similar to approach for searching a spot for inserting an element in Skip list. The basic idea is if –

  1. Key of next node is less than search key then we keep on moving forward on the same level.
  2. Key of next node is greater than the key to be inserted then we store the pointer to current node i at update[i] and move one level down and continue our search.

At the lowest level (0), if the element next to the rightmost element (update[0]) has key equal to the search key, then we have found key otherwise failure. Following is the pseudo code for searching element –

Search(list, searchKey)
x := list -> header
-- loop invariant: x -> key  level downto 0 do
    while x -> forward[i] -> key  forward[i]
x := x -> forward[0]
if x -> key = searchKey then return x -> value
else return failure

Consider this example where we want to search for key 17- 

searching key

Deleting an element from the Skip list

Deletion of an element k is preceded by locating element in the Skip list using above mentioned search algorithm. Once the element is located, rearrangement of pointers is done to remove element form list just like we do in singly linked list. We start from lowest level and do rearrangement until element next to update[i] is not k. After deletion of element there could be levels with no elements, so we will remove these levels as well by decrementing the level of Skip list. Following is the pseudo code for deletion –

Delete(list, searchKey)
local update[0..MaxLevel+1]
x := list -> header
for i := list -> level downto 0 do
    while x -> forward[i] -> key  forward[i]
    update[i] := x
x := x -> forward[0]
if x -> key = searchKey then
    for i := 0 to list -> level do
        if update[i] -> forward[i] ? x then break
        update[i] -> forward[i] := x -> forward[i]
    free(x)
    while list -> level > 0 and list -> header -> forward[list -> level] = NIL do
        list -> level := list -> level – 1

Consider this example where we want to delete element 6 – 

deletion

Here at level 3, there is no element (arrow in red) after deleting element 6. So we will decrement level of skip list by 1. Following is the code for searching and deleting element from Skip List – 

Implementation:

C++ 
// C++ code for searching and deleting element in skip list

#include <bits/stdc++.h>
using namespace std;

// Class to implement node
class Node
{
public:
    int key;

    // Array to hold pointers to node of different level 
    Node **forward;
    Node(int, int);
};

Node::Node(int key, int level)
{
    this->key = key;

    // Allocate memory to forward 
    forward = new Node*[level+1];

    // Fill forward array with 0(NULL)
    memset(forward, 0, sizeof(Node*)*(level+1));
};

// Class for Skip list
class SkipList
{
    // Maximum level for this skip list
    int MAXLVL;

    // P is the fraction of the nodes with level 
    // i pointers also having level i+1 pointers
    float P;

    // current level of skip list
    int level;

    // pointer to header node
    Node *header;
public:
    SkipList(int, float);
    int randomLevel();
    Node* createNode(int, int);
    void insertElement(int);
    void deleteElement(int);
    void searchElement(int);
    void displayList();
};

SkipList::SkipList(int MAXLVL, float P)
{
    this->MAXLVL = MAXLVL;
    this->P = P;
    level = 0;

    // create header node and initialize key to -1
    header = new Node(-1, MAXLVL);
};

// create random level for node
int SkipList::randomLevel()
{
    float r = (float)rand()/RAND_MAX;
    int lvl = 0;
    while(r < P && lvl < MAXLVL)
    {
        lvl++;
        r = (float)rand()/RAND_MAX;
    }
    return lvl;
};

// create new node
Node* SkipList::createNode(int key, int level)
{
    Node *n = new Node(key, level);
    return n;
};

// Insert given key in skip list
void SkipList::insertElement(int key)
{
    Node *current = header;

    // create update array and initialize it
    Node *update[MAXLVL+1];
    memset(update, 0, sizeof(Node*)*(MAXLVL+1));

    /*    start from highest level of skip list
        move the current pointer forward while key 
        is greater than key of node next to current
        Otherwise inserted current in update and 
        move one level down and continue search
    */
    for(int i = level; i >= 0; i--)
    {
        while(current->forward[i] != NULL &&
              current->forward[i]->key < key)
            current = current->forward[i];
        update[i] = current;
    }

    /* reached level 0 and forward pointer to 
       right, which is desired position to 
       insert key. 
    */
    current = current->forward[0];

    /* if current is NULL that means we have reached
       to end of the level or current's key is not equal
       to key to insert that means we have to insert
       node between update[0] and current node */
    if (current == NULL || current->key != key)
    {
        // Generate a random level for node
        int rlevel = randomLevel();

        /* If random level is greater than list's current
           level (node with highest level inserted in 
           list so far), initialize update value with pointer
           to header for further use */
        if(rlevel > level)
        {
            for(int i=level+1;i<rlevel+1;i++)
                update[i] = header;

            // Update the list current level
            level = rlevel;
        }

        // create new node with random level generated
        Node* n = createNode(key, rlevel);

        // insert node by rearranging pointers 
        for(int i=0;i<=rlevel;i++)
        {
            n->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = n;
        }
        cout<<"Successfully Inserted key "<<key<<"\n";
    }
};

// Delete element from skip list
void SkipList::deleteElement(int key)
{
    Node *current = header;

    // create update array and initialize it
    Node *update[MAXLVL+1];
    memset(update, 0, sizeof(Node*)*(MAXLVL+1));

    /*    start from highest level of skip list
        move the current pointer forward while key 
        is greater than key of node next to current
        Otherwise inserted current in update and 
        move one level down and continue search
    */
    for(int i = level; i >= 0; i--)
    {
        while(current->forward[i] != NULL  &&
              current->forward[i]->key < key)
            current = current->forward[i];
        update[i] = current;
    }

    /* reached level 0 and forward pointer to 
       right, which is possibly our desired node.*/
    current = current->forward[0];

    // If current node is target node
    if(current != NULL and current->key == key)
    {
        /* start from lowest level and rearrange
           pointers just like we do in singly linked list
           to remove target node */
        for(int i=0;i<=level;i++)
        {
            /* If at level i, next node is not target 
               node, break the loop, no need to move 
              further level */
            if(update[i]->forward[i] != current)
                break;

            update[i]->forward[i] = current->forward[i];
        }

        // Remove levels having no elements 
        while(level>0 &&
              header->forward[level] == 0)
            level--;
         cout<<"Successfully deleted key "<<key<<"\n";
    }
};

// Search for element in skip list
void SkipList::searchElement(int key)
{
    Node *current = header;

    /*    start from highest level of skip list
        move the current pointer forward while key 
        is greater than key of node next to current
        Otherwise inserted current in update and 
        move one level down and continue search
    */
    for(int i = level; i >= 0; i--)
    {
        while(current->forward[i] &&
               current->forward[i]->key < key)
            current = current->forward[i];

    }

    /* reached level 0 and advance pointer to 
       right, which is possibly our desired node*/
    current = current->forward[0];

    // If current node have key equal to
    // search key, we have found our target node
    if(current and current->key == key) 
        cout<<"Found key: "<<key<<"\n";
};

// Display skip list level wise
void SkipList::displayList()
{
    cout<<"\n*****Skip List*****"<<"\n";
    for(int i=0;i<=level;i++)
    {
        Node *node = header->forward[i];
        cout<<"Level "<<i<<": ";
        while(node != NULL)
        {
            cout<<node->key<<" ";
            node = node->forward[i];
        }
        cout<<"\n";
    }
};

// Driver to test above code
int main()
{
    // Seed random number generator
    srand((unsigned)time(0));

    // create SkipList object with MAXLVL and P 
    SkipList lst(3, 0.5);

    lst.insertElement(3);
    lst.insertElement(6);
    lst.insertElement(7);
    lst.insertElement(9);
    lst.insertElement(12);
    lst.insertElement(19);
    lst.insertElement(17);
    lst.insertElement(26);
    lst.insertElement(21);
    lst.insertElement(25);
    lst.displayList();

    //Search for node 19
    lst.searchElement(19);

    //Delete node 19
    lst.deleteElement(19);
    lst.displayList();
}
Java 
/*package whatever //do not write package name here */

import java.io.*;

// Java code for inserting element in skip list

class GFG {

    // Class to implement node
    static class Node {
        int key;

        // Array to hold pointers to node of different level
        Node forward[];

        Node(int key, int level)
        {
            this.key = key;

            // Allocate memory to forward
            forward = new Node[level + 1];
        }
    };

    // Class for Skip list
    static class SkipList {
        // Maximum level for this skip list
        int MAXLVL;

        // P is the fraction of the nodes with level
        // i pointers also having level i+1 pointers
        float P;

        // current level of skip list
        int level;

        // pointer to header node
        Node header;

        SkipList(int MAXLVL, float P)
        {
            this.MAXLVL = MAXLVL;
            this.P = P;
            level = 0;

            // create header node and initialize key to -1
            header = new Node(-1, MAXLVL);
        }

        int randomLevel()
        {
            float r = (float)Math.random();
            int lvl = 0;
            while (r < P && lvl < MAXLVL) {
                lvl++;
                r = (float)Math.random();
            }
            return lvl;
        }

        Node createNode(int key, int level)
        {
            Node n = new Node(key, level);
            return n;
        }

        // Insert given key in skip list

        void insertElement(int key)
        {
            Node current = header;

            // create update array and initialize it
            Node update[] = new Node[MAXLVL + 1];

            /* start from highest level of skip list
                    move the current pointer forward while
            key is greater than key of node next to
            current Otherwise inserted current in update
            and move one level down and continue search
            */
            for (int i = level; i >= 0; i--) {
                while (current.forward[i] != null && current.forward[i].key < key)
                    current = current.forward[i];
                update[i] = current;
            }

            /* reached level 0 and forward pointer to
            right, which is desired position to
            insert key.
            */
            current = current.forward[0];

            /* if current is NULL that means we have reached
            to end of the level or current's key is not
            equal to key to insert that means we have to
            insert node between update[0] and current node
        */
            if (current == null || current.key != key) {
                // Generate a random level for node
                int rlevel = randomLevel();

                // If random level is greater than list's
                // current level (node with highest level
                // inserted in list so far), initialize
                // update value with pointer to header for
                // further use
                if (rlevel > level) {
                    for (int i = level + 1; i < rlevel + 1;
                         i++)
                        update[i] = header;

                    // Update the list current level
                    level = rlevel;
                }

                // create new node with random level
                // generated
                Node n = createNode(key, rlevel);

                // insert node by rearranging pointers
                for (int i = 0; i <= rlevel; i++) {
                    n.forward[i] = update[i].forward[i];
                    update[i].forward[i] = n;
                }
                System.out.println(
                        "Successfully Inserted key " + key);
            }
        }

        // Display skip list level wise
        void displayList()
        {
            System.out.println("\n*****Skip List*****");
            for (int i = 0; i <= level; i++) {
                Node node = header.forward[i];
                System.out.print("Level " + i + ": ");
                while (node != null) {
                    System.out.print(node.key + " ");
                    node = node.forward[i];
                }
                System.out.println();
            }
        }
        void deleteElement(int key){
            Node current = header;
            // create update array and initialize it
            Node[] update = new Node[MAXLVL+1];

            /* start from highest level of skip list
                    move the current pointer forward while
            key is greater than key of node next to
            current Otherwise inserted current in update
            and move one level down and continue search
            */
            for (int i = level; i >= 0; i--) {
                while (current.forward[i] != null && current.forward[i].key < key)
                    current = current.forward[i];
                update[i] = current;
            }

            /* reached level 0 and forward pointer to
            right, which is desired position to
            delete key.
            */
            current=current.forward[0];

            if(current!=null && current.key==key){

                // delete node by rearranging pointers
                for (int i = 0; i < level; i++) {
                    if (update[i].forward[i] != current)
                        break;
                    update[i].forward[i] = current.forward[i];
                }

                //if it was the only node in that level and you deleted it, delete the level
                while(level>0 && header.forward[level] ==null){
                    level --;
                }
                System.out.println("Successfully deleted key "+ key);
            }

        }

        void Search(int key){

             Node current = header;



            /* start from highest level of skip list
                    move the current pointer forward while
            key is greater than key of node next to
            current    and move one level down and continue search
            */
            for (int i = level; i >=0 ; i--) {
                while (current.forward[i] != null && current.forward[i].key < key) {
                    current = current.forward[i];
                }
            }
                current = current.forward[0];
            // current has to be the key if it is present 
                if(current !=null && current.key==key) {
                    System.out.println("Key found");
                    
                }
                else{
                    System.out.println("Key not found");
                }


            
        }

    }

    // Driver to test above code
    public static void main(String[] args)
    {
        // create SkipList object with MAXLVL and P
        SkipList lst = new SkipList(3, 0.5f);

        lst.insertElement(3);
        lst.insertElement(6);
        lst.insertElement(7);
        lst.insertElement(9);
        lst.insertElement(12);
        lst.insertElement(19);
        lst.insertElement(17);
        lst.insertElement(26);
        lst.insertElement(21);
        lst.insertElement(25);
        lst.displayList();
        lst.deleteElement(9);
        lst.deleteElement(12);
        lst.displayList();
        lst.Search(9);

    }
}
Python 
import random

class Node:
    def __init__(self, key, level):
        self.key = key
        self.forward = [None] * (level + 1)

class SkipList:
    def __init__(self, max_level, p):
        self.MAXLVL = max_level
        self.P = p
        self.level = 0
        self.header = self.create_node(-1, self.MAXLVL)

    def random_level(self):
        lvl = 0
        while random.random() < self.P and lvl < self.MAXLVL:
            lvl += 1
        return lvl

    def create_node(self, key, level):
        return Node(key, level)

    def insert_element(self, key):
        current = self.header
        update = [None] * (self.MAXLVL + 1)

        for i in range(self.level, -1, -1):
            while current.forward[i] and current.forward[i].key < key:
                current = current.forward[i]
            update[i] = current

        current = current.forward[0]

        if not current or current.key != key:
            rlevel = self.random_level()
            if rlevel > self.level:
                for i in range(self.level + 1, rlevel + 1):
                    update[i] = self.header
                self.level = rlevel

            new_node = self.create_node(key, rlevel)

            for i in range(rlevel + 1):
                new_node.forward[i] = update[i].forward[i]
                update[i].forward[i] = new_node

            print(f"Successfully Inserted key {key}")

    def delete_element(self, key):
        current = self.header
        update = [None] * (self.MAXLVL + 1)

        for i in range(self.level, -1, -1):
            while current.forward[i] and current.forward[i].key < key:
                current = current.forward[i]
            update[i] = current

        current = current.forward[0]

        if current and current.key == key:
            for i in range(self.level + 1):
                if update[i].forward[i] != current:
                    break
                update[i].forward[i] = current.forward[i]

            while self.level > 0 and not self.header.forward[self.level]:
                self.level -= 1

            print(f"Successfully deleted key {key}")

    def search_element(self, key):
        current = self.header

        for i in range(self.level, -1, -1):
            while current.forward[i] and current.forward[i].key < key:
                current = current.forward[i]

        current = current.forward[0]

        if current and current.key == key:
            print(f"Found key: {key}")
        else:
            print(f"Key {key} not found")

    def display_list(self):
        print("\n*****Skip List*****")
        for i in range(self.level + 1):
            node = self.header.forward[i]
            print(f"Level {i}: ", end="")
            while node:
                print(node.key, end=" ")
                node = node.forward[i]
            print()

# Driver code
if __name__ == "__main__":
    random.seed()
    lst = SkipList(3, 0.5)

    lst.insert_element(3)
    lst.insert_element(6)
    lst.insert_element(7)
    lst.insert_element(9)
    lst.insert_element(12)
    lst.insert_element(19)
    lst.insert_element(17)
    lst.insert_element(26)
    lst.insert_element(21)
    lst.insert_element(25)
    lst.display_list()

    lst.search_element(19)
    lst.delete_element(19)
    lst.display_list()
C# 
using System;
using System.Collections.Generic;

class Node
{
    // Class to implement node
    public int Key;
    public Node[] Forward;

    public Node(int key, int level)
    {
        Key = key;
        Forward = new Node[level + 1];
    }
}

class SkipList
{
    // Class for Skip list
    private const int MaxLevel = 3; // Maximum level for this skip list
    private readonly double P; // The fraction of nodes with level 
                               // i references also having level i+1 references
    private Node Header; // Header node
    private int Level; // Current level of skip list

    public SkipList(double p)
    {
        P = p;
        Header = new Node(-1, MaxLevel);
        Level = 0;
    }

    // Create new node
    private Node CreateNode(int level, int key)
    {
        return new Node(key, level);
    }

    // Generate random level for a node
    private int RandomLevel()
    {
        int level = 0;
        while (new Random().NextDouble() < P && level < MaxLevel)
        {
            level++;
        }
        return level;
    }

    // Insert given key into skip list
    public void InsertElement(int key)
    {
        // Create an update array and initialize it
        var update = new Node[MaxLevel + 1];
        var current = Header;

        // Start from the highest level of skip list
        // Move the current reference forward while the key
        // is greater than the key of the node next to current
        // Otherwise, insert current into update and move one level down and continue search
        for (var i = Level; i >= 0; i--)
        {
            while (current.Forward[i] != null && current.Forward[i].Key < key)
            {
                current = current.Forward[i];
            }
            update[i] = current;
        }

        // Reached level 0 and forward reference to the right, which is the desired position to insert the key.
        current = current.Forward[0];

        // If current is null or its key is not equal to the key to insert, insert the node between update[0] and current node.
        if (current == null || current.Key != key)
        {
            // Generate a random level for the node
            var randomLevel = RandomLevel();

            // If the random level is greater than the list's current level, initialize update values with references to the header for further use
            if (randomLevel > Level)
            {
                for (var i = Level + 1; i <= randomLevel; i++)
                {
                    update[i] = Header;
                }
                Level = randomLevel;
            }

            // Create a new node with the random level generated
            var newNode = CreateNode(randomLevel, key);

            // Insert the node by rearranging references
            for (var i = 0; i <= randomLevel; i++)
            {
                newNode.Forward[i] = update[i].Forward[i];
                update[i].Forward[i] = newNode;
            }

            Console.WriteLine($"Successfully inserted key {key}");
        }
    }

    // Delete an element with the given search key
    public void DeleteElement(int searchKey)
    {
        // Create an update array and initialize it
        var update = new Node[MaxLevel + 1];
        var current = Header;

        // Start from the highest level of skip list
        // Move the current reference forward while the key 
        // is greater than the key of the node next to current
        // Otherwise, insert current into update and move one level down and continue search
        for (var i = Level; i >= 0; i--)
        {
            while (current.Forward[i] != null && current.Forward[i].Key < searchKey)
            {
                current = current.Forward[i];
            }
            update[i] = current;
        }

        // Reached level 0 and advanced reference to the right, which is possibly our desired node
        current = current.Forward[0];

        // If the current node is the target node
        if (current != null && current.Key == searchKey)
        {
            // Start from the lowest level and rearrange references 
            // just like we do in a singly linked list to remove the target node
            for (var i = 0; i <= Level; i++)
            {
                // If at level i, the next node is not the target node, break the loop
                if (update[i].Forward[i] != current)
                {
                    break;
                }
                update[i].Forward[i] = current.Forward[i];
            }

            // Remove levels having no elements
            while (Level > 0 && Header.Forward[Level] == null)
            {
                Level--;
            }

            Console.WriteLine($"Successfully deleted {searchKey}");
        }
    }

    // Search for an element with the given key
    public void SearchElement(int key)
    {
        var current = Header;

        // Start from the highest level of skip list
        // Move the current reference forward while the key 
        // is greater than the key of the node next to current
        // Otherwise, insert current into update and move one level down and continue search
        for (var i = Level; i >= 0; i--)
        {
            while (current.Forward[i] != null && current.Forward[i].Key < key)
            {
                current = current.Forward[i];
            }
        }

        // Reached level 0 and advanced reference to the right, which is possibly our desired node
        current = current.Forward[0];

        // If the current node has a key equal to the search key, we have found our target node
        if (current != null && current.Key == key)
        {
            Console.WriteLine($"Found key {key}");
        }
    }

    // Display the skip list level-wise
    public void DisplayList()
    {
        Console.WriteLine("\n***** Skip List ******");
        var head = Header;
        for (var lvl = 0; lvl <= Level; lvl++)
        {
            Console.Write($"Level {lvl}: ");
            var node = head.Forward[lvl];
            while (node != null)
            {
                Console.Write(node.Key + " ");
                node = node.Forward[lvl];
            }
            Console.WriteLine();
        }
    }
}

class Program
{
    public static void Main(string[] args)
    {
        var lst = new SkipList(0.5);
        lst.InsertElement(3);
        lst.InsertElement(6);
        lst.InsertElement(7);
        lst.InsertElement(9);
        lst.InsertElement(12);
        lst.InsertElement(19);
        lst.InsertElement(17);
        lst.InsertElement(26);
        lst.InsertElement(21);
        lst.InsertElement(25);
        lst.DisplayList();

        // Search for node 19
        lst.SearchElement(19);

        // Delete node 19
        lst.DeleteElement(19);
        lst.DisplayList();
    }
}
JavaScript 
// Node class
class Node {
    constructor(key, level) {
        this.key = key; // Key of the node
        this.forward = new Array(level + 1); // Array to hold pointers to node of different level
    }
}

// SkipList class
class SkipList {
    constructor(MAXLVL, P) {
        this.MAXLVL = MAXLVL; // Maximum level for this skip list
        this.P = P; // P is the fraction of the nodes with level i pointers also having level i+1 pointers
        this.level = 0; // Current level of skip list
        this.header = new Node(-1, MAXLVL); // Pointer to header node
    }

    // Function to generate random level for node
    randomLevel() {
        let lvl = 0;
        while (Math.random() < this.P && lvl < this.MAXLVL) {
            lvl++;
        }
        return lvl;
    }

    // Function to create a new node
    createNode(key, level) {
        return new Node(key, level);
    }

    // Function to insert element into the skip list
    insertElement(key) {
        let current = this.header;
        let update = new Array(this.MAXLVL + 1);

        // Start from highest level of skip list
        for (let i = this.level; i >= 0; i--) {
            // Move the current pointer forward while key is greater than key of node next to current
            while (current.forward[i] !== undefined && current.forward[i].key < key)
                current = current.forward[i];
            update[i] = current;
        }

        // Reached level 0 and forward pointer to right, which is desired position to insert key
        current = current.forward[0];

        // If current is NULL that means we have reached to end of the level or current's key is not equal to key to insert
        if (current === undefined || current.key !== key) {
            // Generate a random level for node
            let rlevel = this.randomLevel();

            // If random level is greater than list's current level (node with highest level inserted in list so far), initialize update value with pointer to header for further use
            if (rlevel > this.level) {
                for (let i = this.level + 1; i < rlevel + 1; i++)
                    update[i] = this.header;

                // Update the list current level
                this.level = rlevel;
            }

            // Create new node with random level generated
            let n = this.createNode(key, rlevel);

            // Insert node by rearranging pointers
            for (let i = 0; i <= rlevel; i++) {
                n.forward[i] = update[i].forward[i];
                update[i].forward[i] = n;
            }
            console.log("Successfully Inserted key " + key);
        }
    }

    // Function to delete element from the skip list
    deleteElement(key) {
        let current = this.header;
        let update = new Array(this.MAXLVL + 1);

        // Start from highest level of skip list
        for (let i = this.level; i >= 0; i--) {
            // Move the current pointer forward while key is greater than key of node next to current
            while (current.forward[i] !== undefined && current.forward[i].key < key)
                current = current.forward[i];
            update[i] = current;
        }

        // Reached level 0 and forward pointer to right, which is desired position to delete key
        current = current.forward[0];

        // If current is not NULL and current's key is equal to key to delete
        if (current !== undefined && current.key === key) {
            // Delete node by rearranging pointers
            for (let i = 0; i <= this.level; i++) {
                if (update[i].forward[i] !== current)
                    break;
                update[i].forward[i] = current.forward[i];
            }

            // If it was the only node in that level and you deleted it, delete the level
            while (this.level > 0 && this.header.forward[this.level] === undefined) {
                this.level--;
            }
            console.log("Successfully deleted key " + key);
        }
    }

    // Function to search for an element in the skip list
    search(key) {
        let current = this.header;

        // Start from highest level of skip list
        for (let i = this.level; i >= 0; i--) {
            // Move the current pointer forward while key is greater than key of node next to current
            while (current.forward[i] !== undefined && current.forward[i].key < key) {
                current = current.forward[i];
            }
        }

        // Move to right node
        current = current.forward[0];

        // If current is not NULL and current's key is equal to key to search
        if (current !== undefined && current.key === key) {
            console.log("Key found");
        } else {
            console.log("Key not found");
        }
    }

    // Function to display the skip list
    displayList() {
        console.log("\n*****Skip List*****");
        for (let i = 0; i <= this.level; i++) {
            let node = this.header.forward[i];
            let str = "Level " + i + ": ";
            while (node !== undefined) {
                str += node.key + " ";
                node = node.forward[i];
            }
            console.log(str);
        }
    }
}

// Driver code to test above
let lst = new SkipList(3, 0.5);

lst.insertElement(3);
lst.insertElement(6);
lst.insertElement(7);
lst.insertElement(9);
lst.insertElement(12);
lst.insertElement(19);
lst.insertElement(17);
lst.insertElement(26);
lst.insertElement(21);
lst.insertElement(25);
lst.displayList();
lst.deleteElement(9);
lst.deleteElement(12);
lst.displayList();
lst.search(9);

Output
Successfully Inserted key 3
Successfully Inserted key 6
Successfully Inserted key 7
Successfully Inserted key 9
Successfully Inserted key 12
Successfully Inserted key 19
Successfully Inserted key 17
Successfully Inserted key 26
Successfully Inserted key 21
Successfully Inserted key 25

*****Skip List*****
Level 0: 3 6 7 9 12 17 19 21 25 26 
Level 1: 6 9 19 26 
Level 2: 19 
Found key: 19
Successfully deleted key 19

*****Skip List*****
Level 0: 3 6 7 9 12 17 21 25 26 
Level 1: 6 9 26

Time complexity of both searching and deletion is same – Time complexity Worst case:

  • Access – O(n)
  • Search – O(n)
  • Insert – O(n)
  • Space – O(nlogn)
  • Delete – O(n)

 



Like Article
Suggest improvement
Next
Skip List | Set 1 (Introduction)
Share your thoughts in the comments

Similar Reads

Insertion, Searching and Deletion in AVL trees containing a parent node pointer
Skip List | Set 1 (Introduction)
Skip List | Set 2 (Insertion)
m-Way Search Tree | Set-2 | Insertion and Deletion
Deletion in Linked List
Deletion at different positions in a Circular Linked List
Deletion from a Circular Linked List
Deletion in Doubly Circular Linked List
Proto Van Emde Boas Trees | Set 4 | Deletion
Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character | Set 2
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Article Tags :
Practice Tags :
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox