漫画算法：什么是跳跃表？

漫画算法：什么是跳跃表？

// Copyright (C) 2017
// 版权所有。
//
// 文件名：SkipList
// 文件功能描述： 跳跃表的实现 增删查改
// 创建者：zhaoguanghui
// 时间：2017/9/1
// 版本：V1.0.0
//----------------------------------------------------------------*/

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 跳跃表
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
public class SkipList<TKey, TValue> : IDictionary<TKey, TValue> where TKey : IComparable
{
private SkipListNode<TKey, TValue> head;
private int count;

public int Count { get { return count; } }

public bool IsReadOnly { get { return false; } }

public TValue this[TKey key]
{
get
{
return Get(key);
}
set
{
Add(key, value);
}
}

public ICollection<TKey> Keys
{
get
{
List<TKey> keys = new List<TKey>(count);
WalkEntries(n => keys.Add(n.key));
return keys;
}
}

public ICollection<TValue> Values
{
get
{
List<TValue> values = new List<TValue>(count);
WalkEntries(n => values.Add(n.value));
return values;
}
}

private struct SkipListKVPair<W, X>
{
private W key;

public W Key
{
get { return key; }
}

public X Value;

public SkipListKVPair(W key, X value)
{
this.key = key;
this.Value = value;
}
}

private class SkipListNode<TNKey, TNValue>
{
public SkipListNode<TNKey, TNValue> forward, back, up, down;
public SkipListKVPair<TNKey, TNValue> keyValue;
public bool isFront = false;

public TNKey key
{
get { return keyValue.Key; }
}

public TNValue value
{
get { return keyValue.Value; }
set { keyValue.Value = value; }
}

public SkipListNode()
{
this.keyValue = new SkipListKVPair<TNKey, TNValue>(default(TNKey), default(TNValue));
this.isFront = true;
}

public SkipListNode(SkipListKVPair<TNKey, TNValue> keyValue)
{
this.keyValue = keyValue;
}

public SkipListNode(TNKey key, TNValue value)
{
this.keyValue = new SkipListKVPair<TNKey, TNValue>(key, value);
}
}

public SkipList()
{
this.head = new SkipListNode<TKey, TValue>();
count = 0;
}

public void Add(TKey key, TValue value)
{
SkipListNode<TKey, TValue> position;
bool found = Search(key, out position);
if (found)
position.value = value;
else
{
SkipListNode<TKey, TValue> newEntry = new SkipListNode<TKey, TValue>((TKey)key, value);
count++;

//类似双链表
newEntry.back = position;
if (position.forward != null)
{
newEntry.forward = position.forward;
position.forward.back = newEntry;
}
position.forward = newEntry;

Promote(newEntry);
}
}

public void Add(KeyValuePair<TKey, TValue> keyValue)
{
Add(keyValue.Key, keyValue.Value);
}

public void Clear()
{
head = new SkipListNode<TKey, TValue>();
count = 0;
}

public bool ContainsKey(TKey key)
{
SkipListNode<TKey, TValue> notused;
return Search(key, out notused);
}

public bool Contains(KeyValuePair<TKey, TValue> keyValue)
{
return ContainsKey(keyValue.Key);
}

public bool Remove(TKey key)
{
SkipListNode<TKey, TValue> position;
bool found = Search(key, out position);
if (!found)
return false;
else
{
SkipListNode<TKey, TValue> old = position;
do
{
old.back.forward = old.forward;
if (old.forward != null)
old.forward.back = old.back;
old = old.up;
} while (old != null);
count--;
while (head.forward == null)
{
head = head.down;
}
return true;
}
}

public bool Remove(KeyValuePair<TKey, TValue> keyValue)
{
return Remove(keyValue.Key);
}

public bool TryGetValue(TKey key, out TValue value)
{
try
{
value = Get(key);
return true;
}
catch (KeyNotFoundException)
{
value = default(TValue);
return false;
}
}

public void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index");
if (array.IsReadOnly)
throw new ArgumentException("The array argument is Read Only and new items cannot be added to it.");
if (array.IsFixedSize && array.Length < count + index)
throw new ArgumentException("The array argument does not have sufficient space for the SkipList entries.");

int i = index;
WalkEntries(n => array[i++] = new KeyValuePair<TKey, TValue>(n.key, n.value));
}

public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
SkipListNode<TKey, TValue> position = head;
while (position.down != null)
position = position.down;
while (position.forward != null)
{
position = position.forward;
yield return new KeyValuePair<TKey, TValue>(position.key, position.value);
}
}

IEnumerator IEnumerable.GetEnumerator()
{
return (IEnumerator)GetEnumerator();
}

private TValue Get(TKey key)
{
SkipListNode<TKey, TValue> position;
bool found = Search(key, out position);
if (!found)
throw new KeyNotFoundException("Unable to find entry with key \"" + key.ToString() + "\"");
return position.value;
}

private void WalkEntries(Action<SkipListNode<TKey, TValue>> lambda)
{
SkipListNode<TKey, TValue> node = head;
while (node.down != null)
node = node.down;
while (node.forward != null)
{
node = node.forward;
lambda(node);
}
}

private bool Search(TKey key, out SkipListNode<TKey, TValue> position)
{
if (key == null)
throw new ArgumentNullException("key");

SkipListNode<TKey, TValue> current;
position = current = head;
int num = 0;
while ((current.isFront || key.CompareTo(current.key) >= 0) && (current.forward != null || current.down != null))
{
position = current;
if (key.CompareTo(current.key) == 0)
return true;

if (current.forward == null || key.CompareTo(current.forward.key) < 0)
{
if (current.down == null)
return false;
else
current = current.down;
}
else
{
current = current.forward;
}

num++;
}
Debug.Log(num);
position = current;

if (key.CompareTo(position.key) == 0)
return true;
else
return false;
}

private void Promote(SkipListNode<TKey, TValue> node)
{
SkipListNode<TKey, TValue> back = node.back;
SkipListNode<TKey, TValue> last = node;

for (int levels = this.Levels(); levels > 0; levels--)
{
while (back.up == null && !back.isFront)
{
back = back.back;
}

if (back.isFront && back.up == null)
{
back.up = new SkipListNode<TKey, TValue>();
head = back.up;
}

back = back.up;

SkipListNode<TKey, TValue> newNode = new SkipListNode<TKey, TValue>(node.keyValue);
//前
newNode.forward = back.forward;
if (newNode.forward != null)
{
newNode.forward.back = newNode;
}
//后
newNode.back = back;
back.forward = newNode;
//下
newNode.down = last;
last.up = newNode;

last = newNode;
}
}

private int Levels()
{
int levels = 0;
while (UnityEngine.Random.Range(0, 1f) < 0.5)
levels++;
return levels;
}
}