Линейный алгоритм поиска - C#

Формулировка задачи:

Доброго времени суток. И так, нужно найти элементы которые присутствуют только в массиве

или только в массиве

, то бишь исключить повторяющиеся элементы (массивы одномерные). Когда нужно было найти элементы присутствующие в обоих массивах использовался вот такой алгоритм

                    Листинг программы
                
 
                        
                          
                    
int[] c = new int[n + m];
        int count = 0;
 
        for (i = 0; i < a.Length; i++)
        {
            for (j = 0; j < b.Length; j++)
            {
                if (a[i] == b[j])
                {
                    c[count] = a[i];
                    count++;
                }
            }
        }

Но для выше поставленной задачи этот вариант не подходит, та как если просто написать

                    Листинг программы
                
if (a[i] != b[j])

произойдет множественное дублирование. Есть конечно идея сравнивать каждый элемент a[i] со всеми элементами b[j], и уже после этого делать вывод по параметру

                    Листинг программы
                
if (a[i] == b[j])

То бишь если нет ни одного схожего элемента, значит он уникальный и записываем в массив

. Но вот никак не получается это реализовать. Прошу помощи в данном вопросе.

Решение задачи: «Линейный алгоритм поиска»

textual
                            Листинг программы 
                        
 
                            
                        
public void SymmetricExceptWith(IEnumerable<T> other)
    {
      if (other == null)
        throw new ArgumentNullException("other");
      if (this.m_count == 0)
        this.UnionWith(other);
      else if (other == this)
      {
        this.Clear();
      }
      else
      {
        HashSet<T> hashSet = other as HashSet<T>;
        if (hashSet != null && HashSet<T>.AreEqualityComparersEqual(this, hashSet))
          this.SymmetricExceptWithUniqueHashSet(hashSet);
        else
          this.SymmetricExceptWithEnumerable(other);
      }
    }
 
    private void SymmetricExceptWithUniqueHashSet(HashSet<T> other)
    {
      foreach (T obj in other)
      {
        if (!this.Remove(obj))
          this.AddIfNotPresent(obj);
      }
    }
 
    [SecuritySafeCritical]
    private unsafe void SymmetricExceptWithEnumerable(IEnumerable<T> other)
    {
      int n = this.m_lastIndex;
      int length = BitHelper.ToIntArrayLength(n);
      BitHelper bitHelper1;
      BitHelper bitHelper2;
      if (length <= 50)
      {
        int* bitArrayPtr1 = stackalloc int[length];
        bitHelper1 = new BitHelper(bitArrayPtr1, length);
        int* bitArrayPtr2 = stackalloc int[length];
        bitHelper2 = new BitHelper(bitArrayPtr2, length);
      }
      else
      {
        bitHelper1 = new BitHelper(new int[length], length);
        bitHelper2 = new BitHelper(new int[length], length);
      }
      foreach (T obj in other)
      {
        int location = 0;
        if (this.AddOrGetLocation(obj, out location))
          bitHelper2.MarkBit(location);
        else if (location < n && !bitHelper2.IsMarked(location))
          bitHelper1.MarkBit(location);
      }
      for (int bitPosition = 0; bitPosition < n; ++bitPosition)
      {
        if (bitHelper1.IsMarked(bitPosition))
          this.Remove(this.m_slots[bitPosition].value);
      }
    }