Add unrolled linked list (TheAlgorithms#251)

Author: Leefrost

DataStructures.Tests/UnrolledList/UnrolledLinkedListNodeTests.cs

@@ -0,0 +1,61 @@
+using System;
+using DataStructures.UnrolledList;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace DataStructures.Tests.UnrolledList
+{
+    public class UnrolledLinkedListNodeTests
+    {
+        [Test]
+        public void GetAndSet_SetItemNodeAndGetIt_ReturnExpectedItem()
+        {
+            var node = new UnrolledLinkedListNode(6);
+            node.Set(0, 1);
+
+            var result = node.Get(0);
+
+            result.Should().Be(1);
+        }
+
+        [Test]
+        public void Get_GetLowIndex_ThrowArgumentException()
+        {
+            var node = new UnrolledLinkedListNode(6);
+
+            Action action = () => node.Get(-1);
+
+            action.Should().Throw<ArgumentException>();
+        }
+
+        [Test]
+        public void Get_GetHighIndex_ThrowArgumentException()
+        {
+            var node = new UnrolledLinkedListNode(6);
+
+            Action action = () => node.Get(7);
+
+            action.Should().Throw<ArgumentException>();
+        }
+
+        [Test]
+        public void Set_SetLowIndex_ThrowArgumentException()
+        {
+            var node = new UnrolledLinkedListNode(6);
+
+            Action action = () => node.Set(-1, 0);
+
+            action.Should().Throw<ArgumentException>();
+        }
+
+        [Test]
+        public void Set_SetHighIndex_ThrowArgumentException()
+        {
+            var node = new UnrolledLinkedListNode(6);
+
+            Action action = () => node.Set(7, 0);
+
+            action.Should().Throw<ArgumentException>();
+        }
+    }
+}

DataStructures.Tests/UnrolledList/UnrolledLinkedListTests.cs

@@ -0,0 +1,24 @@
+using DataStructures.UnrolledList;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace DataStructures.Tests.UnrolledList
+{
+    public class UnrolledLinkedListTests
+    {
+        [Test]
+        public void Insert_LinkArrayToLinkedList_ReturnArrayHaveSameItems()
+        {
+            var linkedList = new UnrolledLinkedList(6);
+            var contest = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            foreach (var number in contest)
+            {
+                linkedList.Insert(number);
+            }
+
+            var result = linkedList.GetRolledItems();
+
+            result.Should().BeEquivalentTo(contest);
+        }
+    }
+}

DataStructures/UnrolledList/UnrolledLinkedList.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+
+namespace DataStructures.UnrolledList
+{
+    /// <summary>
+    /// Unrolled linked list is a linked list of small arrays,
+    /// all of the same size where each is so small that the insertion
+    /// or deletion is fast and quick, but large enough to fill the cache line.
+    /// </summary>
+    public class UnrolledLinkedList
+    {
+        private readonly int sizeNode;
+
+        private UnrolledLinkedListNode start = null!;
+        private UnrolledLinkedListNode end = null!;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnrolledLinkedList"/> class.
+        /// Create a unrolled list with start chunk size.
+        /// </summary>
+        /// <param name="chunkSize">The size of signe chunk.</param>
+        public UnrolledLinkedList(int chunkSize)
+        {
+            sizeNode = chunkSize + 1;
+        }
+
+        /// <summary>
+        /// Add value to list [O(n)].
+        /// </summary>
+        /// <param name="value">The entered value.</param>
+        public void Insert(int value)
+        {
+            if (start == null)
+            {
+                start = new UnrolledLinkedListNode(sizeNode);
+                start.Set(0, value);
+
+                end = start;
+                return;
+            }
+
+            if (end.Count + 1 < sizeNode)
+            {
+                end.Set(end.Count, value);
+            }
+            else
+            {
+                var pointer = new UnrolledLinkedListNode(sizeNode);
+                var j = 0;
+                for (var pos = end.Count / 2 + 1; pos < end.Count; pos++)
+                {
+                    pointer.Set(j++, end.Get(pos));
+                }
+
+                pointer.Set(j++, value);
+                pointer.Count = j;
+
+                end.Count = end.Count / 2 + 1;
+                end.Next = pointer;
+                end = pointer;
+            }
+        }
+
+        /// <summary>
+        /// Help method. Get all list inside to check the state.
+        /// </summary>
+        /// <returns>Items from all nodes.</returns>
+        public IEnumerable<int> GetRolledItems()
+        {
+            UnrolledLinkedListNode pointer = start;
+            List<int> result = new();
+
+            while (pointer != null)
+            {
+                for (var i = 0; i < pointer.Count; i++)
+                {
+                    result.Add(pointer.Get(i));
+                }
+
+                pointer = pointer.Next;
+            }
+
+            return result;
+        }
+    }
+}

DataStructures/UnrolledList/UnrolledLinkedListNode.cs

@@ -0,0 +1,56 @@
+using System;
+
+namespace DataStructures.UnrolledList
+{
+    /// <summary>
+    /// Single node with array buffer for unrolled list.
+    /// </summary>
+    public class UnrolledLinkedListNode
+    {
+        private readonly int[] array;
+
+        public UnrolledLinkedListNode(int nodeSize)
+        {
+            Next = null!;
+
+            Count = 0;
+            array = new int[nodeSize];
+        }
+
+        public UnrolledLinkedListNode Next { get; set; }
+
+        public int Count { get; set; }
+
+        /// <summary>
+        /// Set new item in array buffer.
+        /// </summary>
+        /// <param name="pos">Index in array.</param>
+        /// <param name="val">The entered value.</param>
+        /// <exception cref="ArgumentException">Index is out of scope.</exception>
+        public void Set(int pos, int val)
+        {
+            if (pos < 0 || pos > array.Length - 1)
+            {
+                throw new ArgumentException("Position is out of size", nameof(pos));
+            }
+
+            array[pos] = val;
+            Count++;
+        }
+
+        /// <summary>
+        /// Get item from array buffer.
+        /// </summary>
+        /// <param name="pos">Index in array.</param>
+        /// <exception cref="ArgumentException">Index is out of scope.</exception>
+        public int Get(int pos)
+        {
+            if (pos < 0 || pos > array.Length - 1)
+            {
+                throw new ArgumentException("Position is out of size", nameof(pos));
+            }
+
+            return array[pos];
+        }
+    }
+}

README.md

@@ -141,6 +141,7 @@ This repository contains algorithms and data structures implemented in C# for ed
     * [Directed Weighted Graph Via Adjacency Matrix](./DataStructures/Graph/DirectedWeightedGraph.cs)
   * [Disjoint Set](./DataStructures/DisjointSet)
   * [SortedList](./DataStructures/SortedList.cs)
+  * [Unrolled linked list](./DataStructures/UnrolledList/UnrolledLinkedList.cs)
 
 
 ## Contributing