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;
}
