C＃中的雙向/雙向字典？

Question

我想存儲在字典中的單詞方式如下：

我可以搭話三字代碼：dict["SomeWord"] - >123和字碼得到一句話：dict[123] - >"SomeWord"

是真的嗎？當然，有一種方法可以做到兩個字典：Dictionary<string,int>和Dictionary<int,string>，但有沒有另外一種方法？

Answer 1

我寫了一個快速幾個類，讓你做你想做的。您可能需要擴展更多功能，但這是一個很好的起點。

中使用的代碼看起來是這樣的：

var map = new Map<int, string>(); 

map.Add(42, "Hello"); 

Console.WriteLine(map.Forward[42]); 
// Outputs "Hello" 

Console.WriteLine(map.Reverse["Hello"]); 
//Outputs 42 

這裏的定義是：

public class Map<T1, T2> 
{ 
    private Dictionary<T1, T2> _forward = new Dictionary<T1, T2>(); 
    private Dictionary<T2, T1> _reverse = new Dictionary<T2, T1>(); 

    public Map() 
    { 
     this.Forward = new Indexer<T1, T2>(_forward); 
     this.Reverse = new Indexer<T2, T1>(_reverse); 
    } 

    public class Indexer<T3, T4> 
    { 
     private Dictionary<T3, T4> _dictionary; 
     public Indexer(Dictionary<T3, T4> dictionary) 
     { 
      _dictionary = dictionary; 
     } 
     public T4 this[T3 index] 
     { 
      get { return _dictionary[index]; } 
      set { _dictionary[index] = value; } 
     } 
    } 

    public void Add(T1 t1, T2 t2) 
    { 
     _forward.Add(t1, t2); 
     _reverse.Add(t2, t1); 
    } 

    public Indexer<T1, T2> Forward { get; private set; } 
    public Indexer<T2, T1> Reverse { get; private set; } 
} 

Answer 2

你可以使用兩個字典，如你所說，或者如果這兩個鍵和值是相同類型的，你可以只使用一個：

dict["SomeWord"]= "123"和dict["123"]="SomeWord"所有使用它的查找。

Answer 3

雖然它使用枚舉，但您可以使用此擴展方法，因此可能不適用於大型數據集。如果你擔心效率，那麼你需要兩本字典。如果你想兩個庫包裝成一個類，請參閱接受的答案對這個問題：Bidirectional 1 to 1 Dictionary in C#

public static class IDictionaryExtensions 
{ 
    public static TKey FindKeyByValue<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TValue value) 
    { 
     if (dictionary == null) 
      throw new ArgumentNullException("dictionary"); 

     foreach (KeyValuePair<TKey, TValue> pair in dictionary) 
      if (value.Equals(pair.Value)) return pair.Key; 

     throw new Exception("the value is not found in the dictionary"); 
    } 
} 

Answer 4

它使用反向查找索引器。
反向查找是O（n），但它也不會超過1項字典實例使用兩個字典

public sealed class DictionaryDoubleKeyed : Dictionary<UInt32, string> 
{ // used UInt32 as the key as it has a perfect hash 
    // if most of the lookup is by word then swap 
    public void Add(UInt32 ID, string Word) 
    { 
     if (this.ContainsValue(Word)) throw new ArgumentException(); 
     base.Add(ID, Word); 
    } 
    public UInt32 this[string Word] 
    { // this will be O(n) 
     get 
     { 
      return this.FirstOrDefault(x => x.Value == Word).Key; 
     } 
    } 
} 

Answer 5

以下包封類利用LINQ（IEnumerable的擴展）。

public class TwoWayDictionary<TKey, TValue> 
{ 
    readonly IDictionary<TKey, TValue> dict; 
    readonly Func<TKey, TValue> GetValueWhereKey; 
    readonly Func<TValue, TKey> GetKeyWhereValue; 
    readonly bool _mustValueBeUnique = true; 

    public TwoWayDictionary() 
    { 
     this.dict = new Dictionary<TKey, TValue>(); 
     this.GetValueWhereKey = (strValue) => dict.Where(kvp => Object.Equals(kvp.Key, strValue)).Select(kvp => kvp.Value).FirstOrDefault(); 
     this.GetKeyWhereValue = (intValue) => dict.Where(kvp => Object.Equals(kvp.Value, intValue)).Select(kvp => kvp.Key).FirstOrDefault(); 
    } 

    public TwoWayDictionary(KeyValuePair<TKey, TValue>[] kvps) 
     : this() 
    { 
     this.AddRange(kvps); 
    } 

    public void AddRange(KeyValuePair<TKey, TValue>[] kvps) 
    { 
     kvps.ToList().ForEach(kvp => {   
      if (!_mustValueBeUnique || !this.dict.Any(item => Object.Equals(item.Value, kvp.Value))) 
      { 
       dict.Add(kvp.Key, kvp.Value); 
      } else { 
       throw new InvalidOperationException("Value must be unique"); 
      } 
     }); 
    } 

    public TValue this[TKey key] 
    { 
     get { return GetValueWhereKey(key); } 
    } 

    public TKey this[TValue value] 
    { 
     get { return GetKeyWhereValue(value); } 
    } 
} 

---

class Program 
{ 
    static void Main(string[] args) 
    { 
     var dict = new TwoWayDictionary<string, int>(new KeyValuePair<string, int>[] { 
      new KeyValuePair<string, int>(".jpeg",100), 
      new KeyValuePair<string, int>(".jpg",101), 
      new KeyValuePair<string, int>(".txt",102), 
      new KeyValuePair<string, int>(".zip",103) 
     }); 


     var r1 = dict[100]; 
     var r2 = dict[".jpg"]; 

    } 

} 

Answer 6

Bictionary

下面是我在回答每一個喜歡攙和。它實現IEnumerable，因此它可以使用集合初始值設定項，如您在示例中所見。

使用限制：

• 您正在使用不同的數據類型。 （即，T1≠T2）

代碼：

using System; 
using System.Collections.Generic; 
using System.Linq; 

public class Program 
{ 
    public static void Main() 
    { 
     Bictionary<string, int> bictionary = 
      new Bictionary<string,int>() { 
       { "a",1 }, 
       { "b",2 }, 
       { "c",3 } 
      }; 

     // test forward lookup 
     Console.WriteLine(bictionary["b"]); 
     // test forward lookup error 
     //Console.WriteLine(bictionary["d"]); 
     // test reverse lookup 
     Console.WriteLine(bictionary[3]); 
     // test reverse lookup error (throws same error as forward lookup does) 
     Console.WriteLine(bictionary[4]); 
    } 
} 

public class Bictionary<T1, T2> : Dictionary<T1, T2> 
{ 
    public T1 this[T2 index] 
    { 
     get 
     { 
      if(!this.Any(x => x.Value.Equals(index))) 
       throw new System.Collections.Generic.KeyNotFoundException(); 
      return this.First(x => x.Value.Equals(index)).Key; 
     } 
    } 
} 

小提琴：

https://dotnetfiddle.net/mTNEuw

Answer 7

通過添加初始化和Contains方法擴展Enigmativity代碼。

public class Map<T1, T2> : IEnumerable<KeyValuePair<T1, T2>> 
{ 
    private readonly Dictionary<T1, T2> _forward = new Dictionary<T1, T2>(); 
    private readonly Dictionary<T2, T1> _reverse = new Dictionary<T2, T1>(); 

    public Map() 
    { 
     Forward = new Indexer<T1, T2>(_forward); 
     Reverse = new Indexer<T2, T1>(_reverse); 
    } 

    public Indexer<T1, T2> Forward { get; private set; } 
    public Indexer<T2, T1> Reverse { get; private set; } 

    public void Add(T1 t1, T2 t2) 
    { 
     _forward.Add(t1, t2); 
     _reverse.Add(t2, t1); 
    } 

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

    public IEnumerator<KeyValuePair<T1, T2>> GetEnumerator() 
    { 
     return _forward.GetEnumerator(); 
    } 

    public class Indexer<T3, T4> 
    { 
     private readonly Dictionary<T3, T4> _dictionary; 

     public Indexer(Dictionary<T3, T4> dictionary) 
     { 
      _dictionary = dictionary; 
     } 

     public T4 this[T3 index] 
     { 
      get { return _dictionary[index]; } 
      set { _dictionary[index] = value; } 
     } 

     public bool Contains(T3 key) 
     { 
      return _dictionary.ContainsKey(key); 
     } 
    } 
} 

下面是一個使用情況，檢查有效括號

public static class ValidParenthesisExt 
{ 
    private static readonly Map<char, char> 
     _parenthesis = new Map<char, char> 
     { 
      {'(', ')'}, 
      {'{', '}'}, 
      {'[', ']'} 
     }; 

    public static bool IsValidParenthesis(this string input) 
    { 
     var stack = new Stack<char>(); 
     foreach (var c in input) 
     { 
      if (_parenthesis.Forward.Contains(c)) 
       stack.Push(c); 
      else 
      { 
       if (stack.Count == 0) return false; 
       if (_parenthesis.Reverse[c] != stack.Pop()) 
        return false; 
      } 
     } 
     return stack.Count == 0; 
    } 
} 

Answer 8

這是一個老問題，但我想補充兩個擴展方法的情況下，任何人發現它是有用的。第二個不是很有用，但它提供了一個起點，如果需要支持一對一的字典。

public static Dictionary<VALUE,KEY> Inverse<KEY,VALUE>(this Dictionary<KEY,VALUE> dictionary) 
    { 
     if (dictionary==null || dictionary.Count == 0) { return null; } 

     var result = new Dictionary<VALUE, KEY>(dictionary.Count); 

     foreach(KeyValuePair<KEY,VALUE> entry in dictionary) 
     { 
      result.Add(entry.Value, entry.Key); 
     } 

     return result; 
    } 

    public static Dictionary<VALUE, KEY> SafeInverse<KEY, VALUE>(this Dictionary<KEY, VALUE> dictionary) 
    { 
     if (dictionary == null || dictionary.Count == 0) { return null; } 

     var result = new Dictionary<VALUE, KEY>(dictionary.Count); 

     foreach (KeyValuePair<KEY, VALUE> entry in dictionary) 
     { 
      if (result.ContainsKey(entry.Value)) { continue; } 

      result.Add(entry.Value, entry.Key); 
     } 

     return result; 
    }