Unrolled Linked List

A linear data structure called an unrolled linked list is a variant on the linked list. Unrolled linked lists store a full array at each node instead of simply one element at each node. Unrolled linked lists combine the advantages of an array (low memory overhead) with the advantages of linked lists (rapid insertion and deletion) to achieve dramatically improved performance. Unrolled linked lists effectively spread out the overhead of linked lists across several items by storing numerous elements at each node.

So, if each node of an unrolled linked list holds an array of four elements, the linked list overhead (pointers) is distributed across those four elements. When you examine the cache management of contemporary CPUs, Unrolled Linked List performs better. When compared to a standard, singly linked list, unrolled linked lists have a somewhat significant overhead per node. However, in most cases, this disadvantage is minor in comparison to the benefits of modern computers.

The unrolled linked list is a linked list in which each node carries an array of values rather than just one. Each node's array can contain anything that a conventional array can, including primitive kinds and other abstract data types. Each node can carry a maximum amount of values, and most implementations keep each node at about 3/4 capacity. When specific arrays become overflowing, it does so by transferring values between them.

The unrolled linked list has a somewhat higher per-node overhead since each node has to store the maximum number of values its array can carry. However, as compared to a standard linked list, it has a far cheaper per-value cost. The average storage space required per value decreases as the maximum size of the array in each node grows, and the space advantages are considerably bigger when the kind of value is very small. The unrolled linked list is a hybrid of an array and a linked list. It takes advantage of the array's ultra-fast indexing and storage locality. The underlying features of static arrays provide both of these advantages. Furthermore, it retains the linked list's advantage of node insertion and deletion.

The algorithm for inserting and deleting elements in an unrolled linked list varies depending on the implementation. The low-water mark is usually set at 50%, which means that if an element cannot be inserted into a node, a new node is constructed, and half of the current node's elements are entered into it. If we delete an element and the number of values in that node falls below 50%, we insert items from an adjacent array into that node to bring it back up to 50%. If that array also falls below 50%, the two nodes are merged.

This puts the average node's utilization at roughly 70-75 percent. With a decent node size, the overhead is quite low when compared to the linked list. Each node in a linked list requires about two or three pieces of overhead. The overhead of the unrolled linked list is amortized across its elements, giving it 1/size, which is similar to the overhead of an array. To adjust the performance of your unrolled linked list, change the low-water mark. You can raise the average utilization of each node by increasing it. This, however, will necessitate more frequent splitting and merging.

Java Code

Now let's write a Java code to implement an Unrolled Linked List which will perform all the basic functions like add, delete and display the node on the Unrolled Linked List.

/*This is a Java Program to implement an Unrolled Linked List. An unrolled linked list is a variation on the linked list which stores multiple elements in each node. It can dramatically increase cache performance while decreasing the memory overhead associated with storing list metadata such as references. It is related to the B-tree.*/


 // A sample Java Program to Implement Unrolled Linked List


import java.util.Scanner;

// A class named ULLNode is created that will act as a single node of the Unrolled Linked List 
class ULLNode
{
    // A variable named next of the ULLNode type is created that will be used to store the address of the next node of the Unrolled Linked Lists
    ULLNode next;
    // A variable named numElements of the integer is created that will be used to store the number of elements in that node of the Unrolled Linked List
    int numElements;
    int array[];


    // A parameterized constructor is written that will be used to initialize the class variables of the ULLNode class
    public ULLNode(int n)
    {
        next = null;
        numElements = 0;
        array = new int[n];
    }
}

// A class named UnrolledLinkedList is created that will have all the utility Functions of the Unrolled Linked List 
class UnrolledLinkedList
{

    // A private variable named start of the ULLNode type is created that will be used to represent the start of the Unrolled Linked List
    private ULLNode start;
    // A private variable named end of the ULLNode type is created that will be used to represent the end of the Unrolled Linked List
    private ULLNode end;
    // A variable named sizeNode of the integer is created that will be used to store the size of the node
    private int sizeNode;
    private int nNode;

    // A parameterized constructor is written that will be used to initialize the class variables of the UnrolledLinkedList class
    public UnrolledLinkedList(int capacity)
    {
        start = null;
        end = null;
        nNode = 0;
        sizeNode = capacity + 1;
    }


    // A public Function named isEmpty() is written that will be used to check whether the Unrolled Linked List is empty or not.
    public boolean isEmpty()
    {
        return start == null;
    }

    // A public Function named getSize() is written that will be used to get the size of the Unrolled Linked List
    public int getSize()
    {
        return nNode;
    }

    // A public Function named makeEmpty() is written that will be used to empty the Unrolled Linked List
    public void makeEmpty()
    {
        start = null;
        end = null;
        nNode = 0;
    }

    // A public Function named insert() is written that will be used to a new element to the Unrolled Linked List
    public void insert(int x)
    {
        nNode++;
        if (start == null)
            {
                start = new ULLNode(sizeNode);
                start.array[0] = x;
                start.numElements++;
                end = start;
                return;
            }
        if (end.numElements + 1 < sizeNode)
            {
                end.array[end.numElements] = x;
                end.numElements++;
            }
        else
            {
                ULLNode nptr = new ULLNode(sizeNode);
                int j = 0;
                for (int i = end.numElements/2 + 1; i < end.numElements; i++)
                    nptr.array[j++] = end.array[i];
                nptr.array[j++] = x;
                nptr.numElements = j;
                end.numElements = end.numElements/2 + 1;
                end.next = nptr;
                end = nptr;
            }
    }

    // A public Function named display() is written that will be used to print all the elements of the Unrolled Linked List
    public void display()
    {
        System.out.print("\nUnrolled Linked List = ");
        if (nNode == 0)
            {
                System.out.print("empty\n");
                return;
            }
        System.out.println();
        ULLNode ptr = start;
        while (ptr != null)
            {
                for (int i = 0; i < ptr.numElements; i++)
                    System.out.print(ptr.array[i] +" ");
                System.out.println();
                ptr = ptr.next;
            }
    }

}

public class UnrolledLinkedListTest
{
    // main function is written to call all the functionalities functions of the Unrolled Linked List Data structure written above
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter array size of each node");
        /* Creating object of class UnrolledLinkedList */
        UnrolledLinkedList ull = new UnrolledLinkedList(scan.nextInt() );
        char ch;
       /*  Perform list operations  */
        do
            {

                System.out.println("Please Choose one of the Operations::");
                System.out.println("1. To insert Data in the Unrolled Linked List.");
                System.out.println("2. To Check List is empty or not.");
                System.out.println("3. To get the size of the Unrolled Linked List.");
                System.out.println("4. To clear the Unrolled Linked List.");
                System.out.println("5. To print/display the Data in the Unrolled Linked List.");
                int choice = scan.nextInt();
                switch (choice)
                    {
                    case 1 :
                        System.out.println("Enter integer element to insert");
                        ull.insert( scan.nextInt() );
                        break;
                    case 2 :
                        System.out.println("Empty status = "+ ull.isEmpty());
                        break;
                    case 3 :
                        System.out.println("Size = "+ ull.getSize() +"\n");
                        break;
                    case 4 :
                        System.out.println("List Cleared\n");
                        ull.makeEmpty();
                        break;
                    case 5 :
                        System.out.println("Contents of Unrolled Linked List are::");
                        ull.display();
                    default :
                        System.out.println("Wrong Entry\n ");
                        break;
                    }
                System.out.println("\nDo you want to continue (Type y or n)\n");
                ch = scan.next().charAt(0);
            }
        while (ch == 'Y'|| ch == 'y');
    }
}// end of code

Output:

The above code gives the following output.

Enter array size of each node
8
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
1
Enter integer element to insert
12

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
1
Enter integer element to insert
2

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
1
Enter integer element to insert
3

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
1
Enter integer element to insert
4

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
5
Contents of Unrolled Linked List are::

Unrolled Linked List = 
1 2 3 4 
Wrong Entry
 

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
2
Empty status = false

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
3
Size = 4


Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
5
Contents of Unrolled Linked List are::

Unrolled Linked List = 
1 2 3 4 

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
5
Contents of Unrolled Linked List are::

Unrolled Linked List = 
1 2 3 4 
Wrong Entry
 

Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
4
List Cleared


Do you want to continue (Type y or n)

y
Please Choose one of the Operations::
1. To insert Data in the Unrolled Linked List.
2. To Check List is empty or not.
3. To get the size of the Unrolled Linked List.
4. To clear the Unrolled Linked List.
5. To print/display the Data in the Unrolled Linked List.
5
Contents of Unrolled Linked List are::

Unrolled Linked List = empty
Wrong Entry
 

Do you want to continue (Type y or n)

n

Advantages

Here are the following advantages of unrolled linked list, such as:

In unrolled linked lists, linear search is substantially faster due to the Cache behavior.
It takes up less storage space for pointers/references than a traditional linked list.
It is faster than typically linked lists at operations like insertion, deletion, and traversal (because search is faster).

Next TopicTypes of Sparse Matrices

← prev next →