IEnumerator <T> IEnumerable <T> .GetEnumerator()
{
DoublyNode <T> current = head;
while (current != null)
{
yield return(current.Value);
current = current.Next;
}
}
IEnumerator <T> IEnumerable <T> .GetEnumerator()
{
DoublyNode <T> current = start;
while (current != null)
{
yield return(current.Data);
current = current.Next;
}
}
public IEnumerable <T> BackEnumerator()
{
DoublyNode <T> current = tail;
while (current != null)
{
yield return(current.Data);
current = current.Previous;
}
}
public bool ReadNext()
{
if (_currentNode.NextNode == null)
{
return(false);
}
_currentNode = _currentNode.NextNode;
CurrentData = _currentNode.Data;
return(true);
}
public bool ReadPrevious()
{
if (_currentNode.PreviousNode == null)
{
return(false);
}
_currentNode = _currentNode.PreviousNode;
CurrentData = _currentNode.Data;
return(true);
}
/** Add a DoublyNode of value val before the first element of the linked list. After the insertion,
* the new DoublyNode will be the first DoublyNode of the linked list. */
public void AddAtHead(int val)
{
DoublyNode cur = new DoublyNode(val);
cur.next = head;
if (head != null)
{
head.prev = cur;
}
head = cur;
size++;
}
public bool Remove(T element)
{
var result = false;
//check to see if list is empty
var isEmptyList = IsEmpty();
//only delete on not empty list
if (!isEmptyList)
{
//one element in the list
if (Head.Next == null)
{
Clear();
result = true;
}
//second element becomes head decrease the size
else if (Head.Data.Equals(element))
{
Head = Head.Next;
Head.Previous = null;
CurrentSize--;
result = true;
}
// find the previous node before the element to be remove
else
{
var foundNode = FindNode(element);
//previous node is found
if (foundNode != null)
{
if (foundNode.Next != null)
{
foundNode.Next = foundNode.Next.Next;
}
else
{
foundNode.Previous.Next = null;
}
CurrentSize--;
result = true;
}
}
}
return(result);
}
public override T Pop()
{
var poppedItem = default(T);
if (!IsEmpty())
{
poppedItem = top.Data;
top = top.Next;
CurrentSize--;
}
return(poppedItem);
}
public T PopFront()
{
if (Count > 0)
{
var result = head.Data;
var current = head.Previous;
current.Next = null;
head = current;
Count--;
return(result);
}
return(default(T));
}
/// <summary>
/// Удаляет первое вхождение указанного объекта из двусвязного списка <see cref="DoublyLinkedList{T}"/>.
/// </summary>
/// <param name="item">Объект, который необходимо удалить из двусвязного списка <see cref="DoublyLinkedList{T}"/>. Для ссылочных типов допускается значение <see cref="null"/>.</param>
/// <returns>Значение <see cref="true"/>, если элемент <paramref name="item"/> успешно удален, в противном случае — значение <see cref="false"/>. Этот метод также возвращает <see cref="false"/>, если элемент <paramref name="item"/> не найден в двусвязном списке <see cref="DoublyLinkedList{T}"/>.</returns>
public bool Remove(T item)
{
var result = false;
if (_head == null || _tail == null)
{
return(result);
}
DoublyNode current = _head;
if (item.Equals(_head.Value))
{
_head = _head.Next;
if (_head != null)
{
_head.Back = null;
}
else
{
_tail = null;
}
result = true;
count--;
}
else if (item.Equals(_tail.Value))
{
_tail = _tail.Back;
if (_tail != null)
{
_tail.Next = null;
}
else
{
_head = null;
}
result = true;
count--;
}
else
{
while (current.Next != null && !current.Next.Value.Equals(item))
{
current = current.Next;
}
(current.Next = current.Next.Next).Back = current;
result = true;
count--;
}
return(result);
}
public bool Contains(T data)
{
DoublyNode <T> current = head;
while (current != null)
{
if (current.Data.Equals(data))
{
return(true);
}
current = current.Next;
}
return(false);
}
public void Insert(T data)
{
DoublyNode <T> newNode = new DoublyNode <T>
{
Data = data,
PreviousNode = _tailNode.PreviousNode
};
_tailNode.PreviousNode.NextNode = newNode;
newNode.NextNode = _tailNode;
_tailNode.PreviousNode = newNode;
CountData++;
}
// обратный порядок в листе (перестановка)
public void Reverse()
{
DoublyNode <T> current = tail;
while (current != null)
{
// добавляем в конец
Add(current.Data);
// удаляем первое вхождение, так как первым будет старое значение
Remove(current.Data);
// переключаемся на предыдущее
current = current.Previous;
}
}
public bool Contains(T value)
{
DoublyNode <T> current = head;
while (current != null)
{
if (current.Value.Equals(value))
{
return(true);
}
current = current.Next;
}
return(false);
}
public void PushBack(T data)
{
if (IsEmpty)
{
SetHead(data);
return;
}
var item = new DoublyNode <T>(data);
item.Next = tail;
tail.Previous = item;
tail = item;
Count++;
}
public void TestRemoveLast()
{
//arrange
int expectedCount = Deque <int> .count - 1;
DoublyNode <int> expectedHead = Deque <int> .tail;
//act
int actualHead = Deque <int> .RemoveLast();
int actualCount = Deque <int> .count;
//assert
Assert.AreEqual(expectedHead.Data, actualHead);
Assert.AreEqual(expectedCount, actualCount);
}
public void Change(T dataToChange, T newData)
{
DoublyNode <T> node = new DoublyNode <T>(dataToChange);
DoublyNode <T> current = start;
while (current != null)
{
if (current.Data.Equals(dataToChange))
{
break;
}
current = current.Next;
}
current.Data = newData;
}
public void PushFront(T data)
{
if (IsEmpty)
{
SetHead(data);
return;
}
var item = new DoublyNode <T>(data);
item.Previous = head;
head.Next = item;
head = item;
Count++;
}
private (DoublyNode <T>?, int) FindNodeWith(T data)
{
DoublyNode <T>?current = Head;
int index = 0;
while (current is not null)
{
if (current.Data.Equals(data))
{
return(current, index);
}
current = current.Next;
index++;
}
return(null, -1);
}
public void Add(T data)
{
DoublyNode <T> node = new DoublyNode <T>(data);
if (start == null)
{
start = node;
}
else
{
end.Next = node;
node.Previous = end;
}
end = node;
count++;
}
public void AddLast(T value)
{
DoublyNode <T> newNode = new DoublyNode <T>(value);
if (head == null)
{
head = newNode;
}
else
{
tail.Next = newNode;
newNode.Previous = tail;
}
tail = newNode;
count++;
}
// добавление элемента
public void Add(T data)
{
DoublyNode <T> node = new DoublyNode <T>(data);
if (Head == null)
{
Head = node;
}
else
{
Tail.Next = node;
node.Previous = Tail;
}
Tail = node;
Count++;
}
public void Add(T data)
{
DoublyNode <T> node = new DoublyNode <T>(data);
if (head == null)
{
head = node;
}
else
{
tail.Next = node;
node.Previous = tail;
}
tail = node;
Сount++;
}
public void TestAddLast()
{
//arrange
var data = 365;
int expectedCount = Deque <int> .count + 1;
DoublyNode <int> expectedTail = new DoublyNode <int>(data);
//act
Deque <int> .AddLast(data);
DoublyNode <int> actualTail = Deque <int> .tail;
int actualCount = Deque <int> .count;
//assert
Assert.AreEqual(expectedTail.Data, actualTail.Data);
Assert.AreEqual(expectedCount, actualCount);
}
public void SwapHeadAndTail()
{
var node = head;
var previous = (DoublyNode <T>)null;
while (node.Next != null)
{
previous = node;
node = node.Next;
}
previous.Next = null;
node.Previous = null;
node.Next = head;
head.Previous = node;
head = node;
}
private DoublyNode <T> ReverseRecursive(DoublyNode <T> head)
{
if (head.Next == null)
{
head.Previous = null;
this.head = head;
return(head);
}
var node = ReverseRecursive(head.Next);
node.Next = head;
head.Previous = node;
return(head);
}
public void AddFirst(T data)
{
DoublyNode <T> node = new DoublyNode <T>(data);
DoublyNode <T> temp = head;
node.Next = temp;
head = node;
if (count == 0)
{
tail = head;
}
else
{
temp.Previous = node;
}
count++;
}
private static bool Calculate(DoublyLinkedList list)
{
DoublyNode current1 = list.Head;
DoublyNode current2 = list.Tail;
while (current1 != null)
{
if (current1.Key != current2.Key)
{
return(false);
}
current1 = current1.Next;
current2 = current2.Prev;
}
return(true);
}
public void Append(T value)
{
var newNode = new DoublyNode <T> {
Value = value
};
if (IsEmpty())
{
head = newNode;
}
else
{
tail.Next = newNode;
newNode.Previous = tail;
tail = newNode;
}
}
public DoublyNode InsertIntoSorted(int item)
{
//1 -> 2 -> 4
//1 -> 2 -> 3(*) -> 4
//* *
var newNode = new DoublyNode(item);
var current = first; // 1
if (current == null) //when list is empty
{
first = newNode;
}
else if (current.value >= item)
{
current.prev = newNode;
newNode.next = current;
first = newNode;
}
else
{
while (current.next != null && current.next.value < item) //1 < 4, 2 < 4 , 4 < 4 = false
{
current = current.next; // 2 , 4
}
//current = 4
newNode.next = current.next;
if (current.next != null)
{
newNode.next.prev = newNode;
}
current.next = newNode;
newNode.prev = current;
}
return(first);
}
