public void RemoveNode(DoubleLinkNode <T> pNode)
{
if (pNode == null)
{
return;
}
if (pNode == Head)
{
Head = pNode.next;
}
if (pNode == Tail)
{
Tail = pNode.prev;
}
if (pNode.prev != null)
{
pNode.prev.next = pNode.next;
}
if (pNode.next != null)
{
pNode.next.prev = pNode.prev;
}
//回收
pNode.next = pNode.prev = null;
pNode.cur = default(T);
m_nodePool.Recycle(pNode);
Count--;
}
public void MoveToHead(DoubleLinkNode <T> pNode)
{
if (pNode == null || pNode == Head)
{
return;
}
if (pNode == Tail)
{
Tail = pNode.prev;
}
if (pNode.prev != null)
{
pNode.prev.next = pNode.next;
}
if (pNode.next != null)
{
pNode.next.prev = pNode.prev;
}
pNode.prev = null;
pNode.next = Head;
Head.prev = pNode;
Head = pNode;
//感觉这种情况不存在
if (Tail == null)
{
Head = Tail;
}
}
public void Put(int key, int value)
{
if (hashMap.ContainsKey(key))
{
var node = hashMap[key];
node.Value = value;
MoveNodeToHead(node);
return;
}
var newNode = new DoubleLinkNode()
{
Key = key,
Value = value
};
hashMap.Add(key, newNode);
AddNodeToHead(newNode);
size++;
if (size > capacity)
{
var node = RemoveLatestNode();
hashMap.Remove(node.Key);
size--;
}
}
private void RemoveNode(DoubleLinkNode node)
{
var previous = node.Prev;
var next = node.Next;
previous.Next = next;
next.Prev = previous;
}
public void Visit(string url)
{
DoubleLinkNode <string> t = new DoubleLinkNode <string>(url);
history.AddAfterNode(current, t);
history.ClearAfter(t);
current = t;
}
public string Forward(int steps)
{
while (current.next != null && steps != 0)
{
current = current.next;
--steps;
}
return(current.Val);
}
public string Back(int steps)
{
while (current.prev != null && steps != 0)
{
current = current.prev;
--steps;
}
return(current.Val);
}
public DoubleLinkNode <T> AddToTail(T t)
{
DoubleLinkNode <T> pNode = m_nodePool.Create(true);
pNode.prev = null;
pNode.next = null;
pNode.cur = t;
return(AddToTail(pNode));
}
public bool Find(T t)
{
DoubleLinkNode <T> node = null;
if (!m_tNodeMap.TryGetValue(t, out node) && node == null)
{
return(false);
}
return(true);
}
public void AddAfterNode(DoubleLinkNode <T> node, DoubleLinkNode <T> nodeToAdd)
{
nodeToAdd.next = node.next;
node.next = nodeToAdd;
nodeToAdd.prev = node;
if (node == Tail)
{
Tail = nodeToAdd;
}
}
private void AddNodeToTail(DoubleLinkNode node)
{
var prev = dummyTail.Prev;
node.Prev = prev;
prev.Next = node;
dummyTail.Prev = node;
node.Next = dummyTail;
}
/** Initialize your data structure here. Set the size of the deque to be k. */
public MyCircularDeque(int k)
{
_head = new DoubleLinkNode(-1);
_tail = new DoubleLinkNode(-1);
_head.next = _tail;
_tail.pre = _head;
_size = 0;
_k = k;
}
private void AddNodeToHead(DoubleLinkNode node)
{
var next = dummyHead.Next;
node.Next = next;
next.Prev = node;
dummyHead.Next = node;
node.Prev = dummyHead;
}
public void Remove(T t)
{
DoubleLinkNode <T> node = null;
if (m_tNodeMap.TryGetValue(t, out node))
{
m_doubleLinkList.RemoveNode(node);
m_tNodeMap.Remove(t);
}
}
public void InsertToHead(T t)
{
DoubleLinkNode <T> node = null;
if (!m_tNodeMap.TryGetValue(t, out node))
{
m_doubleLinkList.AddToHead(t);
m_tNodeMap.Add(t, m_doubleLinkList.Head);
}
}
/// <summary>
/// 移动到表头
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool MoveToHead(T t)
{
DoubleLinkNode <T> node = null;
if (m_tNodeMap.TryGetValue(t, out node) && node != null)
{
m_doubleLinkList.MoveToHead(node);
return(true);
}
return(false);
}
public _0146_LRUCache(int capacity)
{
this.size = 0;
this.capacity = capacity;
this.hashMap = new Dictionary <int, DoubleLinkNode>();
this.dummyHead = new DoubleLinkNode();
this.dummyTail = new DoubleLinkNode();
dummyHead.Next = dummyTail;
dummyTail.Prev = dummyHead;
}
public _1429_FirstUniqueNumber(int[] nums)
{
this.hashMap = new Dictionary <int, DoubleLinkNode>();
this.dummyHead = new DoubleLinkNode();
this.dummyTail = new DoubleLinkNode();
dummyHead.Next = dummyTail;
dummyTail.Prev = dummyHead;
foreach (var num in nums)
{
Add(num);
}
}
public void AddLast(DoubleLinkNode <T> node)
{
if (Tail == null)
{
Head = node;
Tail = node;
}
else
{
Tail.next = node;
node.prev = Tail;
Tail = node;
}
}
public DoubleLinkNode AddAfter(int value)
{
var node = new DoubleLinkNode()
{
Value = value
};
node.Prev = this;
node.Next = this.Next;
this.Next.Prev = node;
this.Next = node;
return(node);
}
public void Setup()
{
node1 = new DoubleLinkNode();
node2 = new DoubleLinkNode();
node3 = new DoubleLinkNode();
node4 = new DoubleLinkNode();
node5 = new DoubleLinkNode();
node6 = new DoubleLinkNode();
node2.InsertAfter(node1);
node3.InsertAfter(node2);
node4.InsertAfter(node3);
node5.InsertAfter(node4);
}
public bool MoveNext()
{///这里是飞哥写的宝码；不要乱动
if (end)
{
return(false);
}
if (node.IsTail)
{
DoubleLinkNode fakeTail = new DoubleLinkNode();
fakeTail.InsertAfter(node);
end = true;
}//else nothing
node = node.Next;
return(true);
//if (node.IsHead && i =_ 0)
//{
// i++;
// j++;
// k++;
// node = node.Next.Previous;
// return true;
//}
//if (node.IsTail && k ==0)
//{
// k++;
// j++;
// node = node.Previous.Next;
// return true;
//}
//if (!node.IsHead && j == 0)
//{
// j++;
// k++;
// node = node.Next.Previous;
// return true;
//}
//if (!node.IsTail)
//{
// node = node.Next;
// return true;
//}
//return false;
}
/** Adds an item at the rear of Deque. Return true if the operation is successful. */
public bool InsertLast(int value)
{
if (_size == _k)
{
return(false);
}
var node = new DoubleLinkNode(value)
{
next = _tail, pre = _tail.pre
};
_tail.pre.next = node;
_tail.pre = node;
_size++;
return(true);
}
public DoubleLinkNode <T> AddToTail(DoubleLinkNode <T> pNode)
{
if (pNode == null)
{
return(null);
}
pNode.next = null;
if (Tail == null)
{
Head = Tail = pNode;
}
else
{
Tail.next = pNode;
pNode.prev = Tail;
Tail = pNode;
}
Count++;
return(Tail);
}
/** Adds an item at the front of Deque. Return true if the operation is successful. */
public bool InsertFront(int value)
{
if (_size == _k)
{
return(false);
}
var node = new DoubleLinkNode(value)
{
pre = _head,
next = _head.next
};
_head.next.pre = node;
_head.next = node;
_size++;
return(true);
}
static void Main(string[] args)
{
var myNode = new DoubleLinkNode();
myNode.ListInsert(5);
myNode.ListInsert(8);
myNode.ListInsert(12);
myNode.ListInsert(34);
myNode.ListInsert(36);
myNode.ListInsert(85);
myNode.ListInsert(242);
Console.WriteLine();
myNode.ListDelete(5);
myNode.ListDelete(8);
myNode.PrintList();
Console.WriteLine();
myNode.ListDelete(5);
myNode.PrintList();
Console.ReadLine();
}
public DoubleLinkNode <T> AddToHead(DoubleLinkNode <T> pNode)
{
if (pNode == null)
{
return(null);
}
pNode.prev = null;
if (Head == null)
{
Head = Tail = pNode;
}
else
{
Head.prev = pNode;
pNode.next = Head;
Head = pNode;
}
Count++;
return(Head);
}
public void Add(int value)
{
if (hashMap.ContainsKey(value))
{
if (hashMap[value] != null)
{
var node = hashMap[value];
hashMap[value] = null;
RemoveNode(node);
}
return;
}
var newNode = new DoubleLinkNode()
{
Value = value
};
hashMap.Add(value, newNode);
AddNodeToTail(newNode);
}
public static long CalculateHighScore(int players, int finalMarble)
{
var scores = new Dictionary <int, long>();
for (int playerIndex = 0; playerIndex <= players - 1; playerIndex++)
{
scores.Add(playerIndex, 0);
}
var currPlayer = 0;
DoubleLinkNode currNode = new DoubleLinkNode()
{
Value = 0
};
currNode.Prev = currNode;
currNode.Next = currNode;
currNode.AddAfter(1);
for (int marbleCount = 2; marbleCount <= finalMarble; marbleCount++)
{
if (marbleCount % 23 == 0)
{
scores[currPlayer] += marbleCount;
currNode = currNode.MoveBackward(7);
scores[currPlayer] += currNode.Value;
currNode = currNode.Remove();
}
else
{
currNode = currNode.MoveForward(1);
currNode = currNode.AddAfter(marbleCount);
}
currPlayer = (currPlayer + 1) % players;
}
return(scores.Max(x => x.Value));
}
private void MoveNodeToHead(DoubleLinkNode node)
{
RemoveNode(node);
AddNodeToHead(node);
}
