CODEWITHSUNDEEP
c#hashset
Graviton
Graviton

Reputation: 83316

HashSet with Index Access

I would need a data structure that

  1. Allows me to add/item to it
  2. Do not allow duplication
  3. access the collection via index

I am thinking about hashset, but HashSet doesn't have an index. What is the data structure that fulfills the above need?

Upvotes: 1

Views: 9334

Answers (5)

user3565920
user3565920

Reputation: 94

You can do it by extending the HashSet, meat of it to see if it contains the element, and thats O(1), reaturn that  element, so no harm done in that case. Here is the derived one:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;

namespace Tester
{
    // Summary:
    //     Represents a set of values.
    //
    // Type parameters:
    //   T:
    //     The type of elements in the hash set.
    [Serializable]
    public class HashSetExt<T> : HashSet<T>
    {
        // Summary:
        //     Initializes a new instance of the System.Collections.Generic.HashSetExt<T> class
        //     that is empty and uses the default equality comparer for the set type.
        public HashSetExt() : base() { }

        public HashSetExt(IEnumerable<T> collection) : base(collection) { }
        public HashSetExt(IEqualityComparer<T> comparer) : base(comparer) { }

        public HashSetExt(IEnumerable<T> collection, IEqualityComparer<T> comparer) : base(collection, comparer) { }

        protected HashSetExt(SerializationInfo info, StreamingContext context) : base(info, context) { }

        public T this[T item]
        {
            get
            {
                if (this.Contains(item))
                {
                    return item;
                }
                throw new KeyNotFoundException();
            }
        }
    }
}

Upvotes: 0

Massimo Zerbini
Massimo Zerbini

Reputation: 3191

I think you need to develope your own List extension class. List can match your point 1 and 3, but to match point 2 you need to override Add methods.

Upvotes: 0

bobbymcr
bobbymcr

Reputation: 24177

How about a collection derived from KeyedCollection<TKey, TItem>? This represents a collection of items where each key is derived from the item itself. By default it does not allow you to add duplicates (i.e. items with the same key). It allows lookup by key or index.

internal class Program
{
    private static void Main(string[] args)
    {
        TestItemCollection items = new TestItemCollection();
        items.Add(new TestItem("a"));
        items.Add(new TestItem("a")); // throws ArgumentException -- duplicate key

        TestItem a = items["a"];
        a = items[0];
    }

    private sealed class TestItem
    {
        public TestItem(string value)
        {
            this.Value = value;
        }

        public string Value { get; private set; }
    }

    private sealed class TestItemCollection : KeyedCollection<string, TestItem>
    {
        public TestItemCollection()
        {
        }

        protected override string GetKeyForItem(TestItem item)
        {
            return item.Value;
        }
    }
}

Upvotes: 3

ojlovecd
ojlovecd

Reputation: 4902

does it work?

class MyHashSet<T> : HashSet<T>
{
    public T this[int index]
    {
        get
        {
            int i = 0;
            foreach (T t in this)
            {
                if (i == index)
                    return t;
                i++;
            }
            throw new IndexOutOfRangeException();
        }
    }
}

Upvotes: 0

Carl Winder
Carl Winder

Reputation: 948

I think what you want is a Dictionary.

Upvotes: 0

Related Questions