Dev

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedFirst.AddFirst.cs

@@ -0,0 +1,33 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="AddFirst(T)"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public void AddFirst(T item)
+    {
+        LinkedListNode<T> newNode = new LinkedListNode<T>(item);
+
+        if (_head == null)
+        {
+            newNode.Next = newNode;
+            newNode.Prev = newNode;
+            _head = newNode;
+        }
+        else
+        {
+            LinkedListNode<T> tail = Tail;
+
+            newNode.Next = _head;
+            newNode.Prev = tail;
+            tail.Next = newNode;
+            _head.Prev = newNode;
+            _head = newNode;
+        }
+
+        _count++;
+        _version++;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.AddLast.cs

@@ -0,0 +1,29 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="AddLast(T)"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public void AddLast(T item)
+    {
+        if (_head == null)
+        {
+            AddFirst(item);
+        }
+        else
+        {
+            LinkedListNode<T> newNode = new LinkedListNode<T>(item);
+            LinkedListNode<T> tail = Tail;
+
+            newNode.Next = _head;
+            newNode.Prev = tail;
+            tail.Next = newNode;
+            _head.Prev = newNode;
+        }
+
+        _count++;
+        _version++;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.AddRange.cs

@@ -0,0 +1,19 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="AddRange(System.Collections.Generic.IEnumerable{T})"/> method
+/// for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public void AddRange(IEnumerable<T> items)
+    {
+        ArgumentNullException.ThrowIfNull(items);
+
+        foreach (T item in items)
+        {
+            AddLast(item);
+        }
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Clear.cs

@@ -0,0 +1,15 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="Clear"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public void Clear()
+    {
+        _head = null;
+        _count = 0;
+        _version++;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Clone.cs

@@ -0,0 +1,29 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="Clone"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public ILinkedList<T> Clone()
+    {
+        CircularDoublyLinkedList<T> clone = new CircularDoublyLinkedList<T>();
+
+        if (_head == null)
+        {
+            return clone;
+        }
+
+        LinkedListNode<T> current = _head;
+
+        do
+        {
+            clone.AddLast(current.Value);
+            current = current.Next;
+        }
+        while (!ReferenceEquals(current, _head));
+
+        return clone;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Contains.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="Contains(T)"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public bool Contains(T item)
+    {
+        if (_head == null)
+        {
+            return false;
+        }
+
+        LinkedListNode<T> current = _head;
+        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
+
+        do
+        {
+            if (comparer.Equals(current.Value, item))
+            {
+                return true;
+            }
+
+            current = current.Next;
+        }
+        while (!ReferenceEquals(current, _head));
+
+        return false;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Count.cs

@@ -0,0 +1,13 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="Count"/> property for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public int Count
+    {
+        get { return _count; }
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Enumeration.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides enumeration for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public IEnumerator<T> GetEnumerator()
+    {
+        if (_head == null)
+        {
+            yield break;
+        }
+
+        LinkedListNode<T> start = _head;
+        LinkedListNode<T> current = start;
+        int version = _version;
+
+        do
+        {
+            if (version != _version)
+            {
+                throw new InvalidOperationException("Collection modified");
+            }
+
+            yield return current.Value;
+            current = current.Next;
+        }
+        while (!ReferenceEquals(current, start));
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.GetNodeDepth.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="ILinkedList{T}.GetNodeDepth"/> implementation
+/// for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public int GetNodeDepth(T item)
+    {
+        if (_head == null)
+        {
+            return -1;
+        }
+
+        int depth = 0;
+        LinkedListNode<T> current = _head;
+        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
+
+        do
+        {
+            if (comparer.Equals(current.Value, item))
+            {
+                return depth;
+            }
+
+            depth++;
+            current = current.Next;
+        }
+        while (!ReferenceEquals(current, _head));
+
+        return -1;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.GetStructuralInfo.cs

@@ -0,0 +1,31 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="ILinkedList{T}.GetStructuralInfo"/> implementation
+/// for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public (int Length, int MidIndex) GetStructuralInfo()
+    {
+        if (_head == null)
+        {
+            return (0, -1);
+        }
+
+        LinkedListNode<T> slow = _head;
+        LinkedListNode<T> fast = _head;
+        int index = 0;
+
+        do
+        {
+            slow = slow.Next;
+            fast = fast.Next.Next;
+            index++;
+        }
+        while (!ReferenceEquals(fast, _head) && !ReferenceEquals(fast.Next, _head));
+
+        return (_count, index);
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.HasCycle.cs

@@ -0,0 +1,14 @@
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="HasCycle"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public bool HasCycle()
+    {
+        // By design, this implementation always represents a circular list.
+        return true;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.PeekFirst.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="PeekFirst"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public T PeekFirst()
+    {
+        if (_head == null)
+        {
+            throw new InvalidOperationException("list is empty");
+        }
+
+        return _head.Value;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.PeekLast.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="PeekLast"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public T PeekLast()
+    {
+        if (_head == null)
+        {
+            throw new InvalidOperationException("List is empty");
+        }
+
+        LinkedListNode<T> tail = Tail;
+        return tail.Value;
+    }
+}

src/Csdsa/DataStructures/LinkedLists/CircularDoublyLinkedList.Remove.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+
+namespace Csdsa.DataStructures.LinkedLists;
+
+/// <summary>
+/// Provides the <see cref="Remove(T)"/> method for <see cref="CircularDoublyLinkedList{T}"/>.
+/// </summary>
+public partial class CircularDoublyLinkedList<T>
+{
+    /// <inheritdoc />
+    public bool Remove(T item)
+    {
+        if (_head == null)
+        {
+            return false;
+        }
+
+        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
+        LinkedListNode<T> current = _head;
+
+        do
+        {
+            if (comparer.Equals(current.Value, item))
+            {
+                if (ReferenceEquals(current, _head))
+                {
+                    RemoveFirst();
+                }
+                else if (ReferenceEquals(current, Tail))
+                {
+                    RemoveLast();
+                }
+                else
+                {
+                    current.Prev.Next = current.Next;
+                    current.Next.Prev = current.Prev;
+                    _count--;
+                    _version++;
+                }
+
+                return true;
+            }
+
+            current = current.Next;
+        }
+        while (!ReferenceEquals(current, _head));
+
+        return false;
+    }
+}