public void Clear()
{
if (_head == null)
{
return;
}
var current = _head;
do
{
var temp = current;
current = current.Next;
temp.Invalidate();
} while (current != _head);
_head = null;
_count = 0;
++_version;
}
private void RemoveNode(DoublyLinkedListNode <T> node)
{
if (node == _head && _count == 1)
{
_head.Invalidate();
_head = null;
}
else
{
if (ReferenceEquals(node, _head))
{
_head = node.Next;
}
node.Prev.Next = node.Next;
node.Next.Prev = node.Prev;
node.Invalidate();
}
--_count;
}
private static DoublyLinkedListNode <T> BuildLinkedList(IEnumerable <T> collection)
{
var head = new DoublyLinkedListNode <T>();
var p = head; // head.next points to the first node
foreach (var item in collection)
{
var node = new DoublyLinkedListNode <T>(item);
p.Next = node;
node.Prev = p;
p = p.Next;
}
// now p points to the last node
p.Next = head.Next;
if (p.Next != null)
{
p.Next.Prev = p;
}
return(head.Next);
}
public void RemoveRange(int index, int count)
{
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (_count < count + index)
{
throw new ArgumentException();
}
if (count == 0)
{
return;
}
var startNode = GetAt(index);
var prevNode = startNode.Prev;
var lastNode = startNode;
for (var i = 0; i < count; i++)
{
var p = lastNode;
lastNode = lastNode.Next;
p.Invalidate();
}
if (_count == count)
{
_head = null;
}
else
{
prevNode.Next = lastNode;
lastNode.Prev = prevNode;
}
_count -= count;
++_version;
}
public void InsertRange(int index, IEnumerable <T> collection)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
if (index < 0 || index > _count)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
var arr = collection.ToArray();
var count = arr.Length;
if (count == 0)
{
return;
}
var newNode = BuildLinkedList(arr);
if (_head == null)
{
_head = newNode;
}
else
{
var node = (index == _count) ? _head : GetAt(index);
var nodePrev = node.Prev;
var newNodePrev = newNode.Prev;
nodePrev.Next = newNode;
newNode.Prev = nodePrev;
newNodePrev.Next = node;
node.Prev = newNodePrev;
}
if (index == 0)
{
_head = newNode;
}
_count += count;
++_version;
}
public bool MoveNext()
{
if (_version != _list._version)
{
throw new InvalidOperationException();
}
if (_node == null)
{
_index = _list.Count + 1;
_current = default(T);
return(false);
}
++_index;
_current = _node.Item;
_node = _node.Next;
if (_node == _list._head)
{
_node = null;
}
return(true);
}
private void Reverse(DoublyLinkedListNode <T> startNode, int maxCount)
{
if (startNode == null || maxCount <= 0)
{
return;
}
var p = startNode;
var prevNode = startNode.Prev;
var lastNode = startNode;
for (var i = 0; i < maxCount; i++)
{
var temp = p.Next;
p.Next = p.Prev;
p.Prev = temp;
lastNode = p;
p = temp; // move forward p
if (p == _head)
{
break;
}
}
if (!(ReferenceEquals(_head, startNode) && maxCount >= _count))
{ // it means not reverse all the list
var lastNodeNext = p;
prevNode.Next = lastNode;
lastNode.Prev = prevNode;
startNode.Next = lastNodeNext;
lastNodeNext.Prev = startNode;
}
if (ReferenceEquals(_head, startNode))
{
_head = lastNode;
}
++_version;
}
private static int RelativeIndexOf(DoublyLinkedListNode <T> startNode, T item, int maxCount, bool frontToBackOrder)
{
if (startNode == null)
{
return(-1);
}
var node = startNode;
var c = EqualityComparer <T> .Default;
var i = 0;
do
{
if (c.Equals(node.Item, item))
{
return(i);
}
if (i++ >= maxCount)
{
break;
}
node = frontToBackOrder ? node.Next : node.Prev;
} while (node != startNode);
return(-1);
}
public DoublyCircularLinkedList()
{
_head = null;
_count = 0;
_version = 0;
}
public DoublyLinkedListNode(T item, DoublyLinkedListNode <T> prev, DoublyLinkedListNode <T> next)
: base(2, item)
{
Next = next;
Prev = prev;
}
