private void AddData(T value, DoubleLinkedListNode <T> currentNode) { if (currentNode.Next == null) { currentNode.Next = new DoubleLinkedListNode <T>(value); currentNode.Next.Prev = currentNode; _tail = currentNode.Next; Count++; } else { AddData(value, currentNode.Next); } }
// Update links of nodes that stands nearby and update their neighboring nodes links. private void UpdateNearbyNodesLinks(DoubleLinkedListNode <T> firstNode, DoubleLinkedListNode <T> secondNode, DoubleLinkedListNode <T> prefirstNode, DoubleLinkedListNode <T> postSecondNode) { firstNode.Prev = secondNode; firstNode.Next = postSecondNode; secondNode.Prev = prefirstNode; secondNode.Next = firstNode; if (prefirstNode != null) { prefirstNode.Next = secondNode; } if (postSecondNode != null) { postSecondNode.Prev = firstNode; } }
// Update links of common nodes and their neighboring nodes. private void UpdateCommonNodesLinks(DoubleLinkedListNode <T> firstNode, DoubleLinkedListNode <T> secondNode, DoubleLinkedListNode <T> preFirstNode, DoubleLinkedListNode <T> postFirstNode, DoubleLinkedListNode <T> preSecondNode, DoubleLinkedListNode <T> postSecondNode) { firstNode.Prev = preSecondNode; firstNode.Next = postSecondNode; secondNode.Prev = preFirstNode; secondNode.Next = postFirstNode; if (preFirstNode != null) { preFirstNode.Next = secondNode; } postFirstNode.Prev = secondNode; preSecondNode.Next = firstNode; if (postSecondNode != null) { postSecondNode.Prev = firstNode; } }
private void Check(T value, DoubleLinkedListNode <T> currentNode) { if (currentNode == null) { _contains = false; return; } if (currentNode.Data.Equals(value)) { _contains = true; return; } else { Check(value, currentNode.Next); } }
private void RemoveData(T value, DoubleLinkedListNode <T> currentNode) { if (currentNode == null) { throw new ArgumentNullException("Can't find any value"); } if (currentNode.Data.Equals(value)) { // Deleting only one element - head and tail if (currentNode.Prev == null && currentNode.Next == null) { _head = null; _tail = null; } // Deleting first node. else if (currentNode.Prev == null && currentNode.Next != null) { currentNode.Next.Prev = null; _head = currentNode.Next; } // Deleting node in the middle. else if (currentNode.Next != null && currentNode.Prev != null) { currentNode.Prev.Next = currentNode.Next; currentNode.Next.Prev = currentNode.Prev; } // Deleting last node. else { currentNode.Prev.Next = null; _tail = currentNode.Prev; } currentNode = null; Count--; } else { RemoveData(value, currentNode.Next); } }
/// <summary> /// Performs swap between elements. /// </summary> /// <param name="firstValue">first value to be swaped.</param> /// <param name="secondValue">second value to be swaped.</param> public bool Swap(T firstValue, T secondValue) { if (!Contains(firstValue)) { return(false); } if (!Contains(secondValue)) { return(false); } // Find nodes that contains that values. Since nodes already exists, don't check result. DoubleLinkedListNode <T> firstNode = GetNodeByValue(firstValue); DoubleLinkedListNode <T> secondNode = GetNodeByValue(secondValue); // Check if nodes stands nearby if (firstNode.Next != null && firstNode.Next.Equals(secondNode)) { SwapNearbyNodes(firstNode, secondNode); } else if (secondNode.Next != null && secondNode.Next.Equals(firstNode)) { SwapNearbyNodes(secondNode, firstNode); } else { // Check if first node before second, otherwise reverse params passed to method. var firstNodeByOrder = GetFirstNodeByOrder(firstNode, secondNode); // Swap values depending on their order. if (firstNodeByOrder.Equals(firstNode)) { SwapCommonNodes(firstNode, secondNode); } else { SwapCommonNodes(secondNode, firstNode); } } return(true); }
private void UpdateHeadAndTail(DoubleLinkedListNode <T> preFirstNode, DoubleLinkedListNode <T> firstNode, DoubleLinkedListNode <T> secondNode, DoubleLinkedListNode <T> postSecondNode) { // Swap head and tail. if (preFirstNode == null && postSecondNode == null) { _head = secondNode; _tail = firstNode; } // Swap head with common element. else if (preFirstNode == null) { _head = secondNode; } // Swap tail with common element. else if (postSecondNode == null) { _tail = firstNode; } }
// Get first node in sequence by value. private DoubleLinkedListNode <T> GetNodeByValue(T value) { DoubleLinkedListNode <T> nodeToBeFind = _head; while (nodeToBeFind != null) { if (nodeToBeFind.Data.Equals(value)) { return(nodeToBeFind); } nodeToBeFind = nodeToBeFind.Next; } if (nodeToBeFind.Equals(_head)) { nodeToBeFind = null; } return(nodeToBeFind); }
// Comparing who stands first in the list - first or second node. private DoubleLinkedListNode <T> GetFirstNodeByOrder(DoubleLinkedListNode <T> firstNode, DoubleLinkedListNode <T> secondNode) { DoubleLinkedListNode <T> firstFacedNode = _head; while (firstFacedNode != null) { if (firstFacedNode.Equals(firstNode)) { firstFacedNode = firstNode; break; } else if (firstFacedNode.Equals(secondNode)) { firstFacedNode = secondNode; break; } firstFacedNode = firstFacedNode.Next; } return(firstFacedNode); }
/// <summary> /// Insert value at the begining of the list. /// </summary> /// <param name="value">value to be inserted.</param> public void AddFirst(T value) { if (_head == null) { _head = new DoubleLinkedListNode <T>(value); _tail = _head; } else if (_head != null && _head.Equals(_tail)) { _head = new DoubleLinkedListNode <T>(value); _head.Next = _tail; _tail.Prev = _head; } else { var head = _head; var nodeAfterHead = _head.Next; _head = new DoubleLinkedListNode <T>(value); _head.Next = head; head.Prev = _head; } Count++; }