public void Test() { var multipleNodesList = new DoubleLinkedListNode { Value = 1, Next = null }; var nextNode = Insert(multipleNodesList, 2); Insert(nextNode, 3); RemoveAt(nextNode); Assert.Equal(new[] { 1, 3 }, TraverseForward(multipleNodesList).Select(i => i.Value)); Assert.Equal(new[] { 3, 1 }, TraverseBackward(TraverseForward(multipleNodesList).Last()).Select(i => i.Value)); }
public void AddLast <T>(DoubleLinkedList <T> @this, DoubleLinkedListNode <T> node) { ValidateNewNode(node); if (@this.Head == null) { InternalInsertNodeToEmptyList(@this, node); } else { InternalInsertNodeBefore(@this, @this.Head, node); } node.List = @this; }
public void AddFirst(T key) { if (First == null) { First = new DoubleLinkedListNode <T>(key); Last = First; } else { First.Prev = new DoubleLinkedListNode <T>(key, First); First = First.Prev; } Size++; }
public DoubleLinkedListNode <T> AddLast <T>(DoubleLinkedList <T> @this, T value) { DoubleLinkedListNode <T> result = new DoubleLinkedListNode <T>(@this, value); if (@this.Head == null) { InternalInsertNodeToEmptyList(@this, result); } else { InternalInsertNodeBefore(@this, @this.Head, result); } return(result); }
public void AddLast(T key) { if (First == null) { First = new DoubleLinkedListNode <T>(key); Last = First; } else { Last.Next = new DoubleLinkedListNode <T>(key, null, Last); Last = Last.Next; } Size++; }
public int Get(int key) { if (!memory.ContainsKey(key)) { return(-1); } DoubleLinkedListNode current = memory[key]; current.Prev = current.Next; head.Prev = current; current.Next = head; current.Prev = null; head = current; return(head.Value); }
void AddToHead(int key, int value) { var newNode = new DoubleLinkedListNode <KeyValuePair <int, int> >() { Data = new KeyValuePair <int, int>(key, value), Prior = null, Next = head }; hashtable[key] = newNode; head.Prior = newNode; head = newNode; }
public void Clear <T>(DoubleLinkedList <T> @this) { DoubleLinkedListNode <T> current = @this.Head; while (current != null) { DoubleLinkedListNode <T> temp = current; current = current.Next; // use Next the instead of "next", otherwise it will loop forever temp.Invalidate(); } @this.Head = null; @this.Count = 0; @this.Version++; }
public bool MoveNext() { if (_node == null) { return(false); } _current = _node.Value; _node = _node.Next; if (_node == _parent._head) { _node = null; } return(true); }
public bool Contains(T item) { DoubleLinkedListNode <T> current = Head; while (current != null) { if (current.Value.Equals(item)) { return(true); } current = current.Next; } return(false); }
public int Get(int key) { if (cache.ContainsKey(key)) { DoubleLinkedListNode result = cache[key]; MoveToHead(result); return(result.Value); } else { DoubleLinkedListNode newHead = new DoubleLinkedListNode(key, key); return(-1); } }
public void InsertAtEnd(T newValue) { if (_first == null) //Empty List { _first = new DoubleLinkedListNode <T>(newValue); _last = _first; return; } else { _last.Next = new DoubleLinkedListNode <T>(newValue); _last.Next.Prev = _last; _last = _last.Next; } }
public void AddLast(DoubleLinkedListNode <T> node) { if (Count == 0) { Head = node; } else { Tail.Next = node; node.Previous = Tail; } Tail = node; Count++; }
public void RemoveFirst() { if (Count != 0) { Head = Head.Next; Count--; if (Count == 0) { Tail = null; } else { Head.Previous = null; } } }
public void RemoveLast() { if (Count != 0) { if (Count == 1) { Head = null; Tail = null; } else { Tail.Previous.Next = null; Tail = Tail.Previous; } Count--; } }
public void AddBefore(DoubleLinkedListNode <T> existingNode, DoubleLinkedListNode <T> newNode) { if (this.count == 0) { return; } if (existingNode == head) { AddFirst(newNode); } else { var node = head; while (true) { if (node == existingNode) { // existing node found var rightNode = existingNode; var leftNode = existingNode.Previous; // point surrounding nodes to new node leftNode.Next = newNode; rightNode.Previous = newNode; // point new node to surrounding nodes newNode.Next = rightNode; newNode.Previous = leftNode; break; } if (node.Next == head) { // the node given was not in this list so we will do nothing return; } node = node.Next; } count++; } }
public DoubleLinkedListNode <T> GetNode(T key) { if (First == null) { return(null); } DoubleLinkedListNode <T> ptr = First; do { if (ptr.Key.Equals(key)) { return(ptr); } ptr = ptr.Next; } while (ptr != null); return(null); }
public bool Contains(T key) { if (First == null) { return(false); } DoubleLinkedListNode <T> ptr = First; do { if (ptr.Key.Equals(key)) { return(true); } ptr = ptr.Next; } while (ptr != null); return(false); }
public bool Remove(T item) { DoubleLinkedListNode <T> previous = null; DoubleLinkedListNode <T> current = Head; /* * 1. EmpltyList - do nothing * 2. Single Ndoe : (Previous is NULL) * 3. Many Nodes * a. node to remove is the first node * b. node to remove is the middle or last */ while (current != null) { if (current.Value.Equals(item)) { if (previous != null) { previous.Next = current.Next; if (current.Next == null) { Tail = previous; } else { current.Next.Previous = previous; } Count--; } else { RemoveFirst(); } return(true); } previous = current; current = current.Next; } return(false); }
public void AddLast(T value) { IDoubleLinkedListNode <T> Temp = new DoubleLinkedListNode <T>() { Value = value }; if (Last != null) { Temp.Prev = Last; Last.Next = Temp; Last = Temp; } else { First = Last = Temp; } Count++; }
static void Main(string[] args) { #region LinkedList SingleLinkedList <int> singleLL = new SingleLinkedList <int>(); SingleLinkedListNode <int> snode1 = new SingleLinkedListNode <int>(20); singleLL.AddFirst(snode1); singleLL.Add(30); singleLL.AddLast(90); singleLL.AddFirst(11); singleLL.PrintList(""); DoubleLinkedList <int> doubleLL = new DoubleLinkedList <int>(); DoubleLinkedListNode <int> node1 = new DoubleLinkedListNode <int>(45); doubleLL.AddFirst(node1); doubleLL.AddLast(90); doubleLL.Add(33); doubleLL.Add(30); doubleLL.Add(31); doubleLL.PrintList(""); #endregion #region Stack // To Evaluate PostFix Expression. PostFixCalculator(); #endregion #region Queue QueueUsingArray <int> queue1 = new QueueUsingArray <int>(); queue1.Enqueue(50); queue1.Enqueue(60); queue1.Enqueue(70); queue1.Enqueue(80); queue1.Enqueue(90); queue1.Dequeue(); queue1.Dequeue(); queue1.Enqueue(50); queue1.Enqueue(60); queue1.Enqueue(70); queue1.Enqueue(80); queue1.Enqueue(90); queue1.Dequeue(); queue1.Dequeue(); queue1.PrintQueue(); QueueUsingList <int> queue2 = new QueueUsingList <int>(); queue2.Enqueue(50); queue2.Enqueue(60); queue2.Enqueue(70); queue2.Enqueue(80); queue2.Enqueue(90); queue2.Dequeue(); queue2.Dequeue(); queue2.Enqueue(50); queue2.Enqueue(60); queue2.Enqueue(70); queue2.Enqueue(80); queue2.Enqueue(90); queue2.Dequeue(); queue2.Dequeue(); queue2.PrintQueue(); #endregion #region Trees #endregion }
public static void TwoWaysListInsert(DoubleLinkedList list, DoubleLinkedListNode node, int iteration) { ComparsionsCount++; if (list.Empty) { list.Add(node); SwapsCount++; StepVisualize(list.ToArray(), iteration, -1, false); } else if (list.Head.Value >= node.Value) { list.AddToHead(node); StepVisualize(list.ToArray(), 0, -1, false); SwapsCount++; } else { int position = 0; DoubleLinkedListNode currentNode = list.Head; while (currentNode.Next != null && currentNode.Next.Value < node.Value) { ComparsionsCount++; currentNode = currentNode.Next; StepVisualize(list.ToArray(), position, -1, false); position++; } node.Next = currentNode.Next; if (currentNode.Next != null) { node.Next.Prev = node; } list.AddAfter(currentNode, node); SwapsCount++; StepVisualize(list.ToArray(), position, -1, true); } }
public void Can_Add_Before_Element() { var linkedList = new DoubleLinkedList <int>(); var node1 = new DoubleLinkedListNode <int>(1); var node2 = new DoubleLinkedListNode <int>(2); var newNode = new DoubleLinkedListNode <int>(3); linkedList.AddFirst(node1); linkedList.AddLast(node2); linkedList.AddBefore(node2, newNode); linkedList.Count.Should().Be(3); linkedList.First.Should().Be(node1); linkedList.Last.Should().Be(node2); linkedList.First.Value.Should().Be(1); linkedList.First.Next.Value.Should().Be(3); linkedList.Last.Value.Should().Be(2); linkedList.Last.Previous.Value.Should().Be(3); }
public void AddFirst(DoubleLinkedListNode <T> node) { DoubleLinkedListNode <T> temp = Head; Head = node; Head.Next = temp; if (Count == 1) { Tail = Head; } else { temp.Previous = Head; } Count++; }
/// <summary> /// 添加节点到尾部 /// </summary> /// <param name="t"></param> /// <returns></returns> public DoubleLinkedListNode <T> AddToTail(DoubleLinkedListNode <T> pNode) { if (pNode == null) { return(null); } pNode.next = null; if (Tail == null) { Head = Tail = pNode; } else { pNode.prev = Tail; Tail.next = pNode; Tail = pNode; } m_Count++; return(Tail); }
/// <summary> /// 添加一个节点到头部 /// </summary> /// <param name="pNode"></param> /// <returns></returns> public DoubleLinkedListNode <T> AddToHeader(DoubleLinkedListNode <T> pNode) { if (pNode == null) { return(null); } pNode.prev = null; if (Head == null) { Head = Tail = pNode; } else { pNode.next = Head; Head.prev = pNode; Head = pNode; } m_Count++; return(Head); }
/// <summary> /// 添加一个节点到头部 /// </summary> /// <returns>DoubleLinkedListNode</returns> public DoubleLinkedListNode <T> AddToHeader(DoubleLinkedListNode <T> node) { if (node == null) { return(null); } node.prev = null; if (head == null) { head = tail = node; } else { node.next = head; head.prev = node; head = node; } _count++; return(head); }
public DoubleLinkedListNode <T> AddToTail(DoubleLinkedListNode <T> pNode) { if (pNode == null) { return(null); } pNode.nextNode = null;//添加的节点必须是个空节点,否则就乱套了 if (Tail == null) { Head = Tail = pNode; } else { pNode.preNode = Tail; Tail.nextNode = pNode; Tail = pNode; } Count++; return(pNode); }
public void Remove(DoubleLinkedListNode <T> node) { var leftNode = node.Previous; var rightNode = node.Next; // point surrounding nodes to each other leftNode.Next = rightNode; rightNode.Previous = leftNode; if (node == head) { head = rightNode; } else if (node == tail) { tail = leftNode; } count--; }
/// <summary> /// 添加一个节点到尾部 /// </summary> /// <returns>DoubleLinkedListNode</returns> public DoubleLinkedListNode <T> AddToTail(DoubleLinkedListNode <T> node) { if (node == null) { return(null); } node.next = null; if (tail == null) { head = tail = node; } else { node.prev = tail; tail.next = node; tail = node; } _count++; return(tail); }
/// <summary> /// Redo functionality. /// </summary> public void Redo() { if (_currentUndoNode == null || _currentUndoNode.Next == null) return; _currentUndoNode = _currentUndoNode.Next; var temp = Map; Map = _currentUndoNode.Value; _currentUndoNode = new DoubleLinkedListNode<MapDefinition>(temp, _currentUndoNode.Previous, _currentUndoNode.Next); if (_currentUndoNode.Previous != null) _currentUndoNode.Previous.Next = _currentUndoNode; MapCanvas.Map = Map; MapCanvas.AdaptiveTileRefresh(Map.UndoInfo.Union(temp.UndoInfo).OrderBy(x => x.Y).ThenBy(c => c.X)); }
/// <summary> /// Starts a new module. /// </summary> /// <param name="width"></param> /// <param name="height"></param> internal void NewModule(int width, int height, IsometricStyle style) { _currentUndoNode = null; Map.ClearAllCells(width, height); foreach( FactionList fl in Factions) fl.Units.Clear(); Map.Iso.Style = style; ThreadPool.QueueUserWorkItem(MapCanvas.RenderMap, null); }
/// <summary> /// Changes a cell's contents, correcting for layer. /// </summary> /// <param name="gridPosition"></param> /// <param name="tileToPlace"></param> public void PaintCell(Point gridPosition, ZTile tileToPlace) { if (!Map.IsOnGrid(gridPosition)) return; // Set correct layer var layer = 1; if (!_useAltEditLayer) { layer = 0; if (tileToPlace.TileType != TileType.Floor) { layer = 3; // Layers 2 & 4 are generally used for wall filler tiles atm if (tileToPlace.Name.Contains("_ct_") || tileToPlace.Name.Contains("_c_") || tileToPlace.Name.Contains("_d_")) layer = 4; if (tileToPlace.Name.Contains("_b_") || tileToPlace.Name.Contains("b&d") ) layer = 2; } if (tileToPlace.Flags.Contains(TileFlag.Ethereal)) layer = 4; } // Check we're not swapping for the same thing if (Map.Cells[gridPosition.X, gridPosition.Y][layer] == tileToPlace) return; // Update the undo buffer with the old info var newNode = new DoubleLinkedListNode<MapDefinition>(Map.Clone(), _currentUndoNode); if (_currentUndoNode != null) _currentUndoNode.Next = newNode; _currentUndoNode = newNode; Map.UndoInfo.Clear(); Map.UndoInfo.UnionWith(Map.LegallyPlaceTile(gridPosition, layer, tileToPlace)); MapCanvas.AdaptiveTileRefresh(Map.UndoInfo.OrderBy(x => x.Y)); }
/// <summary> /// Opens module from file. /// </summary> /// <param name="fileName"></param> /// <param name="iso"></param> internal List<Unit> OpenModule(string fileName, Isometry iso) { _currentUndoNode = null; var tempMod = Module.OpenModule(fileName, iso, false); Map = tempMod.Map; MapCanvas.Map = tempMod.Map; foreach (FactionList fl in Factions) fl.Units.Clear(); foreach (Unit u in tempMod.Roster) { Factions[u.OwnerID].Units.Add(u); } ThreadPool.QueueUserWorkItem(MapCanvas.RenderMap, null); return tempMod.Roster; }