title: 有序集

有序集

有序集合和集合一样也是元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个可以被排序的分数。

有序集合是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的,但分数却可以重复。

下面的示例代码中:abc/10表示TElement为abc,TSource为10

构造有序集

  1. var sorset = new SortSet<string, int>();
函数原型
  1. SortSet<TElement,TSource>(double probable = 0.25, int maxLevel = 32);
  1. SortSet<TElement,TSource>(IComparer<TScore> comparer, double probable = 0.25, int maxLevel = 32);
参数 描述
probable 可能出现层数的概率系数(0-1之间的数)(如：0.25即是25%)
maxLevel 最大层级，默认值32
comparer 自定义比较器，用于比较TSource

Count

获取有序集中元素的数量。

  1. var count = sorset.Count;
函数原型
  1. int Count { get; }

SyncRoot

同步锁。

  1. lock(sortset.SyncRoot)
  2. {
  3. }
函数原型
  1. object SyncRoot { get; }

Clear

清空有序集

  1. // [ "1/0", "2/1", "3/2"]
  2. sortset.Clear();
  3. // [ ]
函数原型
  1. void Clear();

Add

添加一个元素到有序集合，或者如果它已经存在则更新其分数，并排序到正确的位置上。

  1. // [ "1/0", "2/5", "3/10" ]
  2. sortset.Add("abc", 3);
  3. // [ "1/0", "abc/3", "2/5", "3/10" ]
函数原型
  1. void Add(TElement element, TScore score);
参数 描述
element 插入的元素
score 用于排序的分数

Contains

判断有序集中是否存在指定元素。

  1. // [ "a/0", "b/5", "c/10" ]
  2. var exists = sortset.Contains("b");
  3. // exists : true
函数原型
  1. bool Contains(TElement element);
参数 描述
element 指定元素

GetScore

返回有序集中指定元素的分数，如果元素不存在则引发KeyNotFoundException。

  1. // [ "a/0", "b/5", "c/10" ]
  2. var score = sortset.GetScore("b");
  3. // score : 5
函数原型
  1. TScore GetScore(TElement element);
参数 描述
element 指定元素

GetRangeCount

获取分数区间内的元素数量。(包含min或max)

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var num = sortset.GetRangeCount(10, 100);
  3. // num : 2
函数原型
  1. int GetRangeCount(TScore start, TScore end);
参数 描述
start 起始分数(包含)
end 结束分数(包含)

Remove

移除有序集合中的指定的元素，如果移除失败则返回false。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var result = sorset.Remove("c");
  3. // result : true
  4. // [ "a/0", "b/10", "d/101" ]
函数原型
  1. bool Remove(TElement element);
参数 描述
element 指定元素

RemoveRangeByRank

根据指定的排名范围移除范围内的所有元素，并返回移除元素的数量。(包含startRank或stopRank)

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var count = sorset.RemoveRangeByRank(1, 2);
  3. // count : 2
  4. // [ "a/0", "d/101" ]
函数原型
  1. int RemoveRangeByRank(int startRank, int stopRank);
参数 描述
startRank 起始排名，以0为底，包含自身起始排名
stopRank 结束排名，以0为底，包含自身结束排名

RemoveRangeByScore

根据指定的分数范围移除范围内的所有元素，并返回移除元素的数量。(包含startScore或stopScore)

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var count = sorset.RemoveRangeByRank(10, 100);
  3. // count : 2
  4. // [ "a/0", "d/101" ]
函数原型
  1. int RemoveRangeByScore(TScore startScore, TScore stopScore);
参数 描述
startScore 起始分数，包含起始分数
stopScore 结束分数，包含结束分数

GetRank

获取指定元素的排名 , 有序集成员默认按照Score从小到大排序（如果自定义比较函数则按照自定义比较函数顺序为主）。如果返回-1则表示没有找到元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var rank = sorset.GetRank("c");
  3. // rank : 2
函数原型
  1. int GetRank(TElement element);
参数 描述
element 指定元素

GetRevRank

获取指定元素的反向排名 , 有序集成员默认按照Score从大到小排序（如果自定义比较函数则按照自定义比较函数的反向顺序为主）。如果返回-1则表示没有找到元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var rank = sorset.GetRevRank("c");
  3. // rank : 1
函数原型
  1. int GetRevRank(TElement element);
参数 描述
element 指定元素

GetElementRangeByRank

根据排名获取范围内的元素列表，排序按照排名从小到大（给定自定义比较函数则按照自定义比较函数顺序）。(包含startRank或stopRank)

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var elements = sorset.GetElementRangeByRank(1, 2);
  3. // elements[0] : "b/10"
  4. // elements[1] : "c/95"
函数原型
  1. TElement[] GetElementRangeByRank(int startRank, int stopRank);
参数 描述
startRank 起始的排名，排名以0为底，包含自身
stopRank 结束的排名，排名以0为底，包含自身

GetElementRangeByScore

根据分数获取范围内的元素列表，排序按照排名从小到大（给定自定义比较函数则按照自定义比较函数顺序）。(包含startScore或stopScore)

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var elements = sorset.GetElementRangeByScore(10, 100);
  3. // elements[0] : "b/10"
  4. // elements[1] : "c/95"
函数原型
  1. TElement[] GetElementRangeByScore(TScore startScore, TScore stopScore);
参数 描述
startScore 起始的分数，包含自身
stopScore 结束的分数，包含自身

GetElementByRank

根据排名获取元素，排序按照排名从小到大（给定自定义比较函数则按照自定义比较函数顺序）

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.GetElementByRank(2);
  3. // element : "c/95"
函数原型
  1. TElement GetElementByRank(int rank);
参数 描述
rank 排名，排名以0为底

GetElementByRevRank

根据排名获取元素，排序按照排名从大到小（给定自定义比较函数则按照自定义比较函数的相反顺序）

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.GetElementByRevRank(2);
  3. // element : "b/10"
函数原型
  1. TElement GetElementByRevRank(int rank);
参数 描述
rank 排名，排名以0为底

ReverseIterator

反转迭代器迭代顺序，并不是反转整个物理存储顺序。

  1. // 物理顺序：[ "a/0", "b/10", "c/95", "d/101" ]
  2. // foreach顺序：[ "a/0", "b/10", "c/95", "d/101" ]
  3. sorset.ReverseIterator();
  4. // 物理顺序：[ "a/0", "b/10", "c/95", "d/101" ]
  5. // foreach顺序：[ "d/101", "c/95", "b/10", "a/0" ]
函数原型
  1. void ReverseIterator();

First

获取第一个元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.First();
  3. // element : "a/0"
函数原型
  1. TElement First();

Last

获取最后一个元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.Last();
  3. // element : "d/101"
函数原型
  1. TElement Last();

Shift

移除并返回有序集头部的元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.Shift();
  3. // element : "a/0"
  4. // [ "b/10", "c/95", "d/101" ]
函数原型
  1. TElement Shift();

Pop

移除并返回有序集尾部的元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset.Pop();
  3. // element : "d/101"
  4. // [ "a/0", "b/10", "c/95" ]
函数原型
  1. TElement Pop();

this[int]

获取指定排名的元素。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var element = sorset[2];
  3. // element : "b/10"
函数原型
  1. TElement this[int rank] { get; }
参数 描述
rank 排名，排名以0为底

ToArray

将有序集转为数组。

  1. // [ "a/0", "b/10", "c/95", "d/101" ]
  2. var elements = sorset.ToArray();
  3. // elements : [ "a", "b", "c", "d" ]
函数原型
  1. TElement[] ToArray();