public DoublyLinkedListNode DeleteANodeInDoublyLinkedList(int data)
{
DoublyLinkedListNode node = this.head;
Console.WriteLine("---Printing DLL after removing the element---");
while (node != null && node.GetDoublyLinkedListNodeData() != data)
{
node = node.GetDoublyLinkedListNextNode();
}
DoublyLinkedListNode nodeToBeDeleted = node;
node.GetDoublyLinkedListPreviousNode()
.SetDoublyLinkednodeNext(node.GetDoublyLinkedListNextNode());
node.GetDoublyLinkedListNextNode()
.SetDoublyLinkedListNodePrevious(node.GetDoublyLinkedListPreviousNode());
return(this.head);
}
/// <summary>
/// Add the node to the end of the list
/// </summary>
/// <param name="value">The node to add</param>
public void AddLast(DoublyLinkedListNode <T> node)
{
if (Count == 0)
{
Head = node;
}
else
{
Tail.Next = node;
// Before: Head -> 3 <-> 5 -> null
// After: Head -> 3 <-> 5 <-> 7 -> null
// 7.Previous = 5
node.Previous = Tail;
}
Tail = node;
Count++;
}
public bool Remove(T item)
{
DoublyLinkedListNode Previous = null, current = First, next = First.Next;
while (current != null)
{
if (current.Value.Equals(item))
{
if (Previous != null)
{
Previous.Next = next;
if (next == null)
{
Last = Previous;
}
else
{
next.Previous = Previous;
}
}
else
{
First = First.Next;
if (First == null)
{
Last = null;
}
else
{
First.Previous = null;
}
}
Count--;
return(true);
}
Previous = current;
current = next;
next = next?.Next;
}
return(false);
}
public void Add(DoublyLinkedListNode <T> newNode)
{
if (_head is null)
{
_head = newNode;
}
else
{
var current = _head;
// urrent.Next이 for문을 돌 때마다
// 1. 현재 값의 다음 값을 계속 불러온다.
for ( ; current != null && current.Next != null;)
{
current = current.Next;
}
// 추가할 때 양 방향 연결
current.Next = newNode;
newNode.Prev = current;
newNode.Next = null;
}
}
public DoublyLinkedList(params T[] arr)
{
var current = new DoublyLinkedListNode(default(T));
foreach (var elem in arr)
{
DoublyLinkedListNode node = new DoublyLinkedListNode(elem);
if (Count == 0)
{
current = node;
First = current;
}
else
{
current.Next = node;
node.Previous = current;
current = node;
}
Last = current;
Count++;
}
}
/// <summary>
/// Removes the last node from the list
/// </summary>
public void RemoveLast()
{
if (Count != 0)
{
if (Count == 1)
{
Head = null;
Tail = null;
}
else
{
// Before: Head --> 3 --> 5 --> 7
// Tail = 7
// After: Head --> 3 --> 5 --> null
// Tail = 5
// Null out 5's Next pointer
Tail.Previous.Next = null;
Tail = Tail.Previous;
}
Count--;
}
}
/// <summary>
/// Removes the first node from the list.
/// </summary>
public void RemoveFirst()
{
if (Count != 0)
{
// Before: Head -> 3 <-> 5
// After: Head -------> 5
// Head -> 3 -> null
// Head ------> null
Head = Head.Next;
Count--;
if (Count == 0)
{
Tail = null;
}
else
{
// 5.Previous was 3, now null
Head.Previous = null;
}
}
}
/// <summary>
/// Removes an item from the list.
/// </summary>
/// <param name="value">Item to remove. Generic type.</param>
/// <returns>True if an item is removed. Otherwise false.</returns>
/// <exception cref="InvalidOperationException">List is empty.</exception>
public bool Remove(T value)
{
if (_count == 0)
{
throw new InvalidOperationException("List is empty!");
}
if (Head.Value.Equals(value))
{
RemoveFirst();
return(true);
}
else if (Tail.Value.Equals(value))
{
RemoveLast();
return(true);
}
else
{
DoublyLinkedListNode <T> current = Head;
while (current != null)
{
if (current.Value.Equals(value))
{
DoublyLinkedListNode <T> prev = current.Previous;
DoublyLinkedListNode <T> next = current.Next;
prev.Next = next;
next.Previous = prev;
current = null;
_count--;
return(true);
}
current = current.Next;
}
}
return(false);
}
public bool RemoveAt(int index)
{
if (Head == null)
{
return(false);
}
else
{
DoublyLinkedListNode <T> tempnode = Head;
DoublyLinkedListNode <T> prevnode = null;
for (int i = 0; i < index; i++)
{
prevnode = tempnode;
tempnode = tempnode.Next;
}
prevnode.Next = tempnode.Next;
if (tempnode.Next == null)
{
Tail = prevnode.Next;
}
}
return(true);
}
public void SetDoublyLinkedListHead(DoublyLinkedListNode doublyLinkedListNode)
{
head = doublyLinkedListNode;
}
public DoublyLinkedList(DoublyLinkedListNode doublyLinkedListNode)
{
head = doublyLinkedListNode;
}
/// <summary>
/// Clears the items in the list.
/// </summary>
public void Clear()
{
_count = 0;
Head = Tail = null;
}
public void SetDoublyLinkednodeNext(DoublyLinkedListNode doublyLinkedListNode)
{
this.next = doublyLinkedListNode;
}
public void Reset()
{
curNode = first;
}
public ListEnumerator(DoublyLinkedListNode <T> node)
{
first = node;
Reset();
}
public DoublyLinkedListNode(T value, DoublyLinkedListNode <T> previous, DoublyLinkedListNode <T> next)
{
Value = value;
Previous = previous;
Next = next;
}
public DoublyLinkedList()
{
Head = null;
Tail = null;
}
public DoublyLinkedListNode(T value)
{
Value = value;
Previous = null;
Next = null;
}
public void SetDoublyLinkedListNodePrevious(DoublyLinkedListNode doublyLinkedListNode)
{
this.previous = doublyLinkedListNode;
}
