Skip lists are a versatile data structure renowned for their efficient implementation of dictionary-like abstract data types (ADTs). They offer a balanced compromise between simplicity and performance, making them ideal for scenarios requiring dynamic insertion, deletion, and rapid lookup operations. The concept revolves around layers, where each layer facilitates faster access to elements, akin to a hierarchical structure that enhances search efficiency.

This blog aims to guide you through the essential components needed to implement a Skip List in C++ for a dictionary ADT. By leveraging linked structures and probabilistic layer creation, Skip Lists achieve logarithmic time complexity for operations like search and insertion, making them competitive with more complex structures like balanced trees but without their stringent balancing requirements.

Throughout this guide, we will delve into constructing the Skip List class, managing memory dynamically, implementing key functions like insertion and retrieval, and adhering to templating requirements for generic key types. By understanding these components and following the specified requirements diligently, you will grasp the intricacies of Skip Lists and gain practical insights into efficient data structure design and implementation in C++ Assignment.

## Understanding Skip Lists:

- Define Skip Lists and their advantages over other data structures for dictionary operations: Skip lists are probabilistic data structures that offer efficient search, insertion, and deletion operations, making them ideal for implementing dictionary-like structures. They provide logarithmic time complexity for these operations on average, similar to balanced trees but with simpler implementation requirements.
- Explain the basic structure and how layers facilitate fast access: Skip lists consist of multiple levels or layers of linked lists, with each node containing pointers to nodes in lower and higher levels. This layered structure enables faster access to elements by allowing for "skipping" over nodes that do not contain the target key, reducing the average time complexity of operations. This makes skip lists well-suited for applications requiring frequent dictionary operations with varying key distributions.

## Planning the Implementation:

### Discuss the necessary member functions:

**Constructor and Destructor:**- The constructor initializes the skip list, setting up necessary variables and structures.
- The destructor ensures proper memory cleanup, deallocating dynamically allocated nodes.
**Size and isEmpty():**- size() returns the number of distinct keys in the skip list.
- isEmpty() checks if the skip list contains zero keys.
**numLayers():**- Returns the number of layers currently present in the skip list, including the base and top layers.
**height(const Key& k):**- Determines the height (or layer) of a specific key in the skip list.
- Helps in efficiently locating keys by identifying their position within the skip list structure.
**nextKey(const Key& k) and previousKey(const Key& k):**- nextKey() returns the next largest key in the skip list after a given key.
- previousKey() returns the previous smallest key in the skip list before a given key.
- Both functions assist in navigation within the skip list for sequential key access.
**find(const Key& k):**- Retrieves a modifiable reference to the value associated with a specific key in the skip list.
- Allows for updating or accessing the stored value for a given key.
**insert(const Key& k, const Value& v):**- Inserts a new key-value pair into the skip list if the key does not already exist.
- Utilizes probabilistic techniques to determine the appropriate level of insertion to maintain skip list properties.
**allKeysInOrder():**- Returns a vector containing all keys in ascending order, facilitating iteration and verification of skip list contents.
**isSmallestKey(const Key& k) and isLargestKey(const Key& k):**- isSmallestKey() checks if a given key is the smallest key in the skip list.
- isLargestKey() checks if a given key is the largest key in the skip list.
- Both functions provide boundary checks for keys within the skip list.

### Emphasize the importance of templating for generic key types:

- Templating allows the SkipList class to handle keys of any type that supports comparison operations (<, >).
- Ensures flexibility and reusability of the skip list implementation across different data types without code duplication.
- Templating also enforces type safety, preventing unintended data type mismatches during compilation.
- Facilitates adherence to assignment requirements regarding support for numeric and string keys, as well as custom data types defined by users.

By implementing these member functions and utilizing templating effectively, the SkipList class can provide a robust and efficient dictionary ADT implementation in C++, meeting both functional requirements and performance expectations.

## Setting Up the SkipList Class:

### Constructor and Destructor

**Constructor
**

The constructor initializes the skip list, setting up necessary variables and structures. Here’s how it can be implemented:

```
template
```
class SkipList {
private:
// Define your node structure
struct Node {
Key key;
Value value;
std::vector next; // Pointers to next nodes at each level
Node(const Key& k, const Value& v, size_t levels)
: key(k), value(v), next(levels, nullptr) {}
};
// Private member variables
Node* head; // Pointer to the head node of the skip list
size_t currentSize; // Number of distinct keys in the skip list
public:
// Constructor
SkipList() {
head = new Node(Key(), Value(), 1); // Initialize head with default key and value
currentSize = 0;
}
// Destructor
~SkipList() {
// Cleanup memory by deleting all nodes
Node* curr = head;
while (curr) {
Node* next = curr->next[0];
delete curr;
curr = next;
}
}
};

### Explanation:

**Constructor (SkipList()):
**

- Initializes the skip list with a default head node.
- head is initialized with a default key (Key()) and value (Value()), assuming these types have default constructors.
- currentSize is initialized to zero since the skip list starts empty.

**Destructor (~SkipList()):
**

- Iterates through the skip list from head to nullptr, deleting each node.
- Ensures proper memory cleanup by freeing allocated memory for nodes.

Implementing Basic Member Functions

size(), isEmpty(), and numLayers()

```
public:
// Function to return the number of distinct keys in the skip list
size_t size() const noexcept {
return currentSize;
}
// Function to check if the skip list is empty
bool isEmpty() const noexcept {
return size() == 0;
}
// Function to return the number of layers currently present in the skip list
unsigned numLayers() const noexcept {
// Assuming a fixed initial configuration of two layers (base and top)
return 2;
}
};
```

### Explanation:

**size() const noexcept:
**

- Returns the current number of distinct keys in the skip list (currentSize).
- const ensures that the function does not modify the object and noexcept indicates it does not throw exceptions.

**isEmpty() const noexcept:
**

- Checks if the skip list is empty by verifying if size() equals zero.
- const ensures the function does not modify the skip list.

**numLayers() const noexcept:
**

- Returns the number of layers currently present in the skip list.
- For simplicity, this implementation assumes a fixed initial configuration with two layers (base and top).

## Handling Key Heights and Operations:

Implementing the height(), nextKey(), and previousKey() functions in the SkipList class involves navigating through the skip list structure to retrieve specific information about keys and their positions. Additionally, using exceptions like RuntimeException ensures robust error handling for scenarios where operations cannot proceed as expected.

### Implementing height() Function

The height(const Key& k) const function determines the layer or height of a specific key in the skip list.

```
public:
unsigned height(const Key & k) const {
Node* current = head;
int level = current->next.size() - 1; // Start from the topmost layer
while (level >= 0) {
if (current->next[level] != nullptr && current->next[level]->key <= k) {
current = current->next[level]; // Move to the next node at the current level
} else {
level--; // Move down to the lower level
}
}
// Check if the current node matches the key
if (current->key == k) {
return current->next.size(); // Return the number of layers (height) at the current node
} else {
throw RuntimeException("Key not found in skip list."); // Throw exception if key is not found
}
}
```

### Explanation:

**height(const Key& k) const:
**

- Takes a key k as input and finds its height in the skip list.
- Starts from the top layer and iterates down to the base layer using the skip list's structure.
- Returns the number of layers (height) of the node containing the key k.
- Throws a RuntimeException if the key is not found in the skip list.

### Implementing nextKey() and previousKey() Functions

The nextKey(const Key& k) const and previousKey(const Key& k) const functions navigate through the skip list to find the next largest and previous smallest keys, respectively.

```
public:
Key nextKey(const Key& k) const {
Node* current = head;
// Traverse through the layers to find the key
for (int i = current->next.size() - 1; i >= 0; --i) {
while (current->next[i] != nullptr && current->next[i]->key < k) {
current = current->next[i]; // Move to the next node at the current level
}
}
// Check if the current node's key is the next largest
if (current->key == k && current->next[0] != nullptr) {
return current->next[0]->key; // Return the next largest key
} else {
throw RuntimeException("Key not found or no next key available.");
}
}
Key previousKey(const Key& k) const {
Node* current = head;
// Traverse through the layers to find the key
for (int i = current->next.size() - 1; i >= 0; --i) {
while (current->next[i] != nullptr && current->next[i]->key < k) {
current = current->next[i]; // Move to the next node at the current level
}
}
// Check if the current node's key is the previous smallest
if (current->next[0] != nullptr && current->next[0]->key == k) {
return current->key; // Return the previous smallest key
} else {
throw RuntimeException("Key not found or no previous key available.");
}
}
```

### Explanation:

**nextKey(const Key& k) const:
**

- Finds the next largest key in the skip list after k.
- Traverses through the layers to locate the key k and returns the next node's key.
- Throws a RuntimeException if the key k is not found or if there is no next key available.

**previousKey(const Key& k) const:
**

- Finds the previous smallest key in the skip list before k.
- Similar to nextKey(), traverses through the layers to locate the key k and returns the previous node's key.
- Throws a RuntimeException if the key k is not found or if there is no previous key available.

### Exception Handling with Runtime Exception

Using Runtime Exception ensures that unexpected scenarios, such as key not found or no available next/previous key, are handled gracefully. This improves the robustness of the skip list operations by providing clear error messages and preventing runtime crashes.

## Implementing Find and Insert Operations:

Complexity and Importance of the insert() Function

The insert() function in a skip list is critical for efficiently adding new key-value pairs while maintaining the structure's balance and ensuring fast lookup times. Here, we'll discuss its complexity, importance, and how it adheres to layer constraints.

### Complexity Considerations

**Time Complexity:
**

On average, inserting into a skip list takes O(logn)O(\log n)O(logn) time, where nnn is the number of elements in the skip list. This complexity arises from the probabilistic nature of skip lists, where elements may propagate upwards through multiple layers.

**Space Complexity:
**

Skip lists use O(nlogn)O(n \log n)O(nlogn) space on average due to the multiple layers maintained for each element. This space complexity accounts for storing nodes across different layers.

### Importance of insert()

**Maintaining Balanced Structure:**The insert() function ensures that the skip list remains balanced. By probabilistically deciding how many layers to propagate a new element, it prevents skewing towards unbalanced configurations, thereby maintaining O(logn)O(\log n)O(logn) search and insertion times.**Efficient Lookup:**Properly implemented, insert() optimizes lookup times by ensuring that subsequent searches benefit from the skip list's layered structure. This makes it ideal for applications requiring frequent updates and fast access.**Layer Constraints Adherence:**The function must adhere to specific layer constraints outlined in the assignment, such as limiting the number of layers based on the number of elements present in the skip list. This ensures that the skip list remains manageable and doesn't excessively consume memory.

### Implementation of insert() Function

```
public:
bool insert(const Key& k, const Value& v) {
// Check if key already exists
if (find(k) != nullptr) {
return false; // Key already exists, return false
}
// Determine height of new node
int newHeight = generateRandomHeight();
Node* newNode = new Node(k, v, newHeight); // Create new node with random height
// Adjust skip list layers if necessary
while (head->next.size() < newHeight) {
head->next.push_back(nullptr); // Extend head's next pointers to accommodate new layers
}
Node* current = head;
for (int i = head->next.size() - 1; i >= 0; --i) {
while (current->next[i] != nullptr && current->next[i]->key < k) {
current = current->next[i]; // Move to the next node at the current level
}
if (i < newHeight) {
newNode->next[i] = current->next[i]; // Connect new node's next pointers
current->next[i] = newNode;
}
}
return true; // Successfully inserted key-value pair
}
```

### Explanation:

**insert(const Key& k, const Value& v):
**

- Checks if the key k already exists using the find() function. If it exists, returns false to indicate no insertion.
- Generates a random height for the new node using a function like generateRandomHeight() (not shown here for simplicity).
- Creates a new node newNode with key k and value v, and adjusts the skip list's layers to accommodate the new node's height.
- Traverses through the layers of the skip list to find the correct position to insert the new node while maintaining the sorted order.
- Connects the new node's next pointers to link it correctly within the skip list structure.

### Implementing find() Function

The find() function retrieves the value associated with a given key k in the skip list.

```
public:
Value* find(const Key& k) const {
Node* current = head;
for (int i = head->next.size() - 1; i >= 0; --i) {
while (current->next[i] != nullptr && current->next[i]->key < k) {
current = current->next[i]; // Move to the next node at the current level
}
}
if (current->next[0] != nullptr && current->next[0]->key == k) {
return &(current->next[0]->value); // Return pointer to value associated with key k
} else {
return nullptr; // Key not found, return nullptr
}
}
```

### Explanation:

**find(const Key& k) const:
**

- Traverses through the layers of the skip list to find the node containing the key k.
- Returns a pointer to the value associated with key k if found.
- Returns nullptr if the key k is not found in the skip list.

## Managing Key Order and Constraints:

### Implementing allKeysInOrder() Function

The allKeysInOrder() function retrieves all keys stored in a skip list in ascending order. Here’s how you can implement it:

```
public:
std::vector
```
allKeysInOrder() const {
std::vector
keys;
Node* current = head->next[0]; // Start from the first node after the head
while (current != nullptr) {
keys.push_back(current->key); // Collect keys in ascending order
current = current->next[0]; // Move to the next node
}
return keys;
}

### Explanation:

allKeysInOrder() const:

- Initializes an empty vector keys to store keys in ascending order.
- Starts from the first node after the head (head->next[0]) and iterates through the skip list.
- Pushes each key into the keys vector until it reaches the end of the skip list (current == nullptr).
- Returns the keys vector containing all keys in ascending order.

### Implementing isSmallestKey() and isLargestKey() Functions

These functions determine if a given key is the smallest or largest key in the skip list, respectively. Here are their implementations:

```
public:
bool isSmallestKey(const Key& k) const {
Node* smallest = head->next[0]; // Smallest key is the first node after the head
if (smallest == nullptr) {
throw RuntimeException("Skip list is empty");
}
return smallest->key == k;
}
bool isLargestKey(const Key& k) const {
Node* current = head;
while (current->next[0] != nullptr) {
current = current->next[0]; // Traverse to the last node in the skip list
}
if (current == head) {
throw RuntimeException("Skip list is empty");
}
return current->key == k;
}
```

### Explanation:

**isSmallestKey(const Key& k) const:
**

- Retrieves the smallest key in the skip list, which is located in head->next[0].
- Throws a RuntimeException if the skip list is empty.
- Checks if the smallest key (smallest->key) matches the given key k and returns true if they match, indicating k is the smallest key in the skip list.

**isLargestKey(const Key& k) const:
**

- Traverses through the skip list to find the last node (current) using the bottom layer (head->next[0]).
- Throws a RuntimeException if the skip list is empty.
- Checks if the last node's key (current->key) matches the given key k and returns true if they match, indicating k is the largest key in the skip list.

## Finalizing the Implementation:

- Emphasize the use of linked structures and the prohibition on using standard library containers.
- Discuss memory management considerations and ensure the implementation meets performance expectations.

## Conclusion

Skip lists offer significant advantages for implementing dictionary ADTs by providing efficient balance between simplicity and performance. They excel in scenarios requiring dynamic insertion and quick lookup operations, achieving logarithmic time complexity without the stringent balancing requirements of other structures like balanced trees. For students, rigorous testing of each function—from constructors to accessors and modifiers—is crucial to ensure accurate implementation and deepen understanding of skip list principles. It's essential to grasp the role of each function in maintaining data integrity and efficient operation of the skip list. Adhering to assignment requirements such as templating for generic key types and using linked structures reinforces academic integrity and prepares students for practical coding challenges. By embracing these principles and testing methodologies, students can enhance their comprehension of data structures and algorithms while honing their problem-solving skills in software development