Question

我有一些具有整数序列的类，这些序列在另一个类中注册，该类检查序列中的数字是否尚未使用。

序列是最连续的，从一个数字到另一个数字。

现在我一直在使用一个简单的List，这意味着如果一个序列代表5000到15000，那么List中将有10000个元素。我想用一个更合适的东西替换它，它可以代表一个简单元素中的范围。

在我的特定情况下，我也希望这些范围代表一个对象（序列所源自的类），这样当我查找一个数字时，我可以访问它的原点而不是查看每个类来查找看看它们是否包含我正在寻找的数字。

这是我的伪代码，其中包含我期望的结果：

/* int is the integer type, while string is the "tag" object */
var animals = new IntRangeArray<int, string>();

animals.Add(1, "dog");
// [0] begin: 1, end: 1, object: "dog"

animals.Add(2, "dog");
// [0] begin: 1, end: 2, object: "dog"

/* AddRange with C#7.0 ValueTuple */
animals.AddRange((4,14), "dog");
// [0] begin: 1, end: 2, object: "dog"
// [1] begin: 4, end: 14, object: "dog"

animals.Add(3, "dog");
// [0] begin: 1, end: 14, object: "dog" 
/* All sequences have been merged because they are contiguous and have the same tag */

animals.AddRange( new int[]{ 15, 17, 18, 19 }, "dog");
// [0] begin: 1, end: 15, object: "dog"
// [1] begin: 17, end: 19, object: "dog"

animals.Add(16, "cat"); 
// [0] begin: 1, end: 15, object: "dog"
// [1] begin: 16, end: 16, object: "cat"
// [2] begin: 17, end: 19, object: "dog"

animals.Remove(8);
// [0] begin: 1, end: 7, object: "dog"
// [1] begin: 9, end: 15, object: "dog"
// [2] begin: 16, end: 16, object: "cat"
// [3] begin: 17, end: 18, object: "dog"

animals.At(11);
// struct { Begin = 9, End = 15, Tag = "dog" }

animals.RemoveWithTag("dog");
// [0] begin: 16, end: 16, object: "cat"

animals.TagOf(16);
// "cat"

我在.NET Framework中找不到实现此行为的任何类，因此我想知道如何实现此操作或者是否存在任何已实现的实现。

Answer 1

对于这种事情，我通常最终会编写自己的课程。以下是我要做的事情：

首先是Range类，其中包含Begin，End和Tag。它还有一些辅助方法来简化查询重叠和相邻的范围，或者用于不区分大小写的标记比较，以及输出字符串值：

class Range
{
    public int Begin { get; set; }
    public int End { get; set; }
    public string Tag { get; set; }

    public bool CombineWith(Range other)
    {
        Range combinedRange;
        if (TryCombine(this, other, out combinedRange))
        {
            this.Begin = combinedRange.Begin;
            this.End = combinedRange.End;
            return true;
        }

        return false;
    }

    public bool IsAdjacentTo(Range other)
    {
        return AreAdjacent(this, other);
    }

    public bool OverlapsWith(Range other)
    {
        return AreOverlapping(this, other);
    }

    public bool ContainsIndex(int index)
    {
        return this.Begin <= index && this.End >= index;
    }

    public bool TagEquals(string tag)
    {
        if (this.Tag == null) return tag == null;
        return this.Tag.Equals(tag, StringComparison.OrdinalIgnoreCase);
    }

    public static bool TryCombine(Range first, Range second, out Range combined)
    {
        combined = new Range();

        if (first == null || second == null) return false;
        if (!TagsEqual(first, second)) return false;
        if (!AreAdjacent(first, second) && !AreOverlapping(first, second)) return false;

        combined.Begin = Math.Min(first.Begin, second.Begin);
        combined.End = Math.Max(first.End, second.End);
        combined.Tag = first.Tag;

        return true;
    }

    public static bool AreAdjacent(Range first, Range second)
    {
        if (first == null || second == null) return false;
        if (!Range.TagsEqual(first, second)) return false;

        return (first.Begin == second.End + 1) ||
               (first.End == second.Begin - 1);
    }

    public static bool AreOverlapping(Range first, Range second)
    {
        if (first == null || second == null) return false;

        return (first.Begin >= second.Begin && first.Begin <= second.End) ||
               (first.End >= second.Begin && first.End <= second.End);
    }

    public static bool TagsEqual(Range first, Range second)
    {
        if (first == null || second == null) return false;
        return first.TagEquals(second.Tag);
    }

    public override string ToString()
    {
        return $"begin: {Begin}, end: {End}, tag: {Tag}";
    }
}

接下来是您的IntRangeArray类，它管理Range个对象列表中项目的添加和删除：

class IntRangeArray
{
    private readonly List<Range> ranges = new List<Range>();

    public bool Add(int index, string tag)
    {
        return AddRange(index, index, tag);
    }

    public bool AddRange(IEnumerable<int> indexes, string tag)
    {
        if (indexes == null || string.IsNullOrWhiteSpace(tag)) return false;

        bool result = true;

        foreach (var index in indexes)
        {
            if (!Add(index, tag)) result = false;
        }

        return result;
    }

    public bool AddRange(Tuple<int, int> range, string tag)
    {
        return AddRange(range.Item1, range.Item2, tag);
    }

    public bool AddRange(int begin, int end, string tag)
    {
        if (begin < 0 || end < 0 || string.IsNullOrWhiteSpace(tag)) return false;

        var newRange = new Range {Begin = begin, End = end, Tag = tag};
        var overlappingRanges = ranges.Where(r => r.OverlapsWith(newRange)).ToList();
        var adjacentRanges = ranges.Where(r => r.IsAdjacentTo(newRange)).ToList();

        if (overlappingRanges.Any())
        {
            if (!overlappingRanges.All(r => r.TagEquals(newRange.Tag)))
            {
                return false;
            }

            foreach (var overlappingRange in overlappingRanges)
            {
                newRange.CombineWith(overlappingRange);
                ranges.Remove(overlappingRange);
            }
        }

        foreach (var adjacentRange in adjacentRanges)
        {
            newRange.CombineWith(adjacentRange);
            ranges.Remove(adjacentRange);
        }

        ranges.Add(newRange);
        return true;
    }

    public string At(int index)
    {
        var matchingRange = ranges.SingleOrDefault(r => r.ContainsIndex(index));
        return matchingRange?.ToString() ?? $"No item exists at {index}";
    }

    public void Remove(int index)
    {
        var matchingRange = ranges.SingleOrDefault(r => r.ContainsIndex(index));
        if (matchingRange == null) return;

        if (matchingRange.Begin == matchingRange.End)
        {
            ranges.Remove(matchingRange);
        }
        else if (index == matchingRange.Begin)
        {
            matchingRange.Begin += 1;
        }
        else if (index == matchingRange.End)
        {
            matchingRange.End -= 1;
        }
        else
        {
            // Split the range by creating a new one for the beginning
            var newRange = new Range
            {
                Begin = matchingRange.Begin,
                End = index - 1,
                Tag = matchingRange.Tag
            };

            matchingRange.Begin = index + 1;
            ranges.Add(newRange);
        }            
    }

    public void RemoveWithTag(string tag)
    {
        ranges.RemoveAll(r => r.TagEquals(tag));
    }

    public string TagOf(int index)
    {
        var matchingRange = ranges.SingleOrDefault(r => r.ContainsIndex(index));
        return matchingRange == null ? $"No item exists at {index}" : matchingRange.Tag;
    }

    public override string ToString()
    {
        if (ranges == null || !ranges.Any()) return "No items exist.";

        ranges.Sort((x, y) => x.Begin.CompareTo(y.Begin));
        var output = new StringBuilder();

        for(int i = 0; i < ranges.Count; i++)
        {
             output.AppendLine($"[{i}] {ranges[i]}");
        }

        return output.ToString();
    }
}

为了测试它，我只是复制并粘贴了上面的代码示例：

private static void Main()
{
    /* int is the integer type, while string is the "tag" object */
    var animals = new IntRangeArray();

    animals.Add(1, "dog");
    Console.WriteLine(animals);

    animals.Add(2, "dog");
    Console.WriteLine(animals);

    /* AddRange with C#7.0 ValueTuple */
    animals.AddRange(Tuple.Create(4, 14), "dog");
    Console.WriteLine(animals);

    animals.Add(3, "dog");
    Console.WriteLine(animals);

    animals.AddRange(new int[] { 15, 17, 18, 19 }, "dog");
    Console.WriteLine(animals);

    animals.Add(16, "cat");
    Console.WriteLine(animals);

    animals.Remove(8);
    Console.WriteLine(animals);

    Console.WriteLine(animals.At(11));

    animals.RemoveWithTag("dog");
    Console.WriteLine(animals);

    Console.WriteLine(animals.TagOf(16));

    Console.WriteLine("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}

输出正如您所料（除了有一个项目不同，但这是您身边的错误）：

Answer 2

这是我的实施。我创建了一个帮助类来使用SortedList管理整数范围，然后使用Dictionary来创建主类来管理标记的整数范围以合并标记。

class IntegerRangeCollection {
    SortedList<int, int> ranges = new SortedList<int, int>();

    public class Range {
        public int begin, end;
    }

    public IntegerRangeCollection() {
    }

    public IntegerRangeCollection(int b, int e) {
        this.Add(b, e);
    }

    public void Add(int b, int e) {
        if (ranges.Any()) {
            if (ranges.ContainsKey(b)) {
                if (e > ranges[b])
                    ranges[b] = e;
            }
            else
                ranges.Add(b, e);
            FixUp();
        }
        else
            ranges.Add(b, e); // new ranges list
    }

    public void Add(int p) => this.Add(p, p);

    public void Remove(int p) {
        var r = ranges.Where(pr => pr.Key <= p && p <= pr.Value).First();
        if (r.Key == p) { // Remove Range begin
            ranges.Remove(r.Key);
            if (p+1 <= r.Value)
                ranges.Add(p+1, r.Value);
        }
        else if (p == r.Value) // Remove Range end
            ranges[r.Key] = p - 1;
        else { // Split Range
            ranges[r.Key] = p-1;
            ranges.Add(p+1, r.Value);
        }
    }

    public Range At(int n) {
        var kvr = ranges.Where(kv => kv.Key <= n && n <= kv.Value);
        if (kvr.Any()) {
            var kvrf = kvr.First();
            return new Range { begin = kvrf.Key, end = kvrf.Value };
        }
        else
            return null;
    }
    public bool Contains(int n) => ranges.Where(kv => kv.Key <= n && n <= kv.Value).Any();
    public bool IsEmpty() => !ranges.Any();

    private bool DoFixUp() { // remove any overlapping ranges
        foreach (var r in ranges) {
            foreach (var pr in ranges.Where(pr => r.Key != pr.Key && r.Value == pr.Key - 1)) { // consolidate adjacent ranges
                ranges.Remove(pr.Key);
                ranges[r.Key] = pr.Value;
                return true;
            }
            foreach (var pr in ranges.Where(pr => r.Key != pr.Key && pr.Key <= r.Value && r.Value <= pr.Value)) { // overlap end
                if (pr.Key > r.Key) { // partial overlap, extend beginning
                    ranges.Remove(pr.Key);
                    ranges[r.Key] = pr.Value;
                    return true;
                }
                else { // complete overlap, remove
                    ranges.Remove(r.Key);
                    return true;
                }
            }
        }

        return false;
    }

    private void FixUp() {
        while (DoFixUp())
            ;
    }
}

class ObjectRangeCollection<objType> where objType : class {
    Dictionary<objType, IntegerRangeCollection> d = new Dictionary<objType, IntegerRangeCollection>();

    public void Add(int begin, int end, objType obj) {
        if (d.TryGetValue(obj, out var ranges))
            ranges.Add(begin, end);
        else
            d.Add(obj, new IntegerRangeCollection(begin, end));
    }

    public void Add(int p, objType obj) => Add(p, p, obj);
    public void AddRange(ValueTuple<int, int> r, objType obj) => Add(r.Item1, r.Item2, obj);
    public void AddRange(int[] rs, objType obj) {
        foreach (var r in rs)
            this.Add(r, r, obj);
    }

    public class AtAnswer {
        public int begin, end;
        public object tag;
    }

    public AtAnswer At(int p) {
        var possibles = d.Where(kv => kv.Value.Contains(p));
        if (possibles.Any()) {
            var kv = possibles.First();
            var r = kv.Value.At(p);
            return new AtAnswer { tag = kv.Key, begin = r.begin, end = r.end };
        }
        else
            return null;
    }

    public objType TagOf(int p) {
        var possibles = d.Where(kv => kv.Value.Contains(p));
        if (possibles.Any())
            return possibles.First().Key;
        else
            return null;
    }

    public void Remove(int p) {
        var possibles = d.Where(kv => kv.Value.Contains(p));
        if (possibles.Any()) {
            foreach (var kv in possibles) {
                kv.Value.Remove(p);
                if (kv.Value.IsEmpty())
                    d.Remove(kv.Key);
            }
        }
    }

    public void RemoveWithTag(objType aTag) {
        d.Remove(aTag);
    }
}

Answer 3

尝试这样的事情

List<KeyValuePair<int, string>> animals = new List<KeyValuePair<int,string>>();
           List<KeyValuePair<int, string>> newValues = Enumerable.Repeat(1,11).Select((x,i) => new KeyValuePair<int,string>(i + 4, "dog")).ToList();
            animals.AddRange(newValues);

Answer 4

Dictionary<string, List<Tuple<int, int>>> Test = new Dictionary<string, 
List<Tuple<int, int>>>();

   int rangebegin=1;
   int rangeend=4;
Test.Add("dog", new List<Tuple<int, int>> 
{ new Tuple<int, int>(rangebegin, rangend) });

   rangebegin=16;
   rangend=22;
Test[dog].Add(new Tuple<int, int>(rangebegin, rangeend));


  // multiple ranges stored under same key
  // you can easily calculate which range your number is in and get 
   //  that range

C＃中的整数范围列表

4 个答案: