一个算法，求牛人帮解答，不胜感激额

举个栗子：
A   B
C   B
B   D
B   E
A   E
E   F
F   G

M N
o N
M N
上面的列表中A,B,C,D,E,F,G是有关的，这些人与M,N,O都没关系，本人要取出A,B,C,D,E,F,G这些人，问一下有什么方法可以取到，仅限C#程序或SQLServer数据库。

解决方案

取出数据后，设置起点，然后迭代就行了啊

void Demo(List<T> source,string find,Hashset<string> result)
{
        var tmp = source.Where(t=>t.C1 == find);
        if(tmp.Any())
        {
             result.Add(find);//这里需要判断下,hashset貌似直接Add会异常
             foreach(var t in tmp)
             {
                    Demo(source,t.C2,result);
             }
        }
}

写了一个，由于按照最初始的理解来写代码，可能算法比较繁琐的（尚未进行任何重构）

using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApplication1
{
    class Program
    {
        class testClass
        {
            public testClass(string _c1, string _c2)
            {
                this.C1 = _c1;
                this.C2 = _c2;
            }
            public string C1 { get; set; }
            public string C2 { get; set; }
        }
        static void Main(string[] args)
        {
            List<testClass> listClass = new List<testClass>();
            listClass.Add(new testClass("A", "B"));
            listClass.Add(new testClass("C", "B"));
            listClass.Add(new testClass("B", "D"));
            listClass.Add(new testClass("B", "E"));
            listClass.Add(new testClass("A", "E"));
            listClass.Add(new testClass("E", "F"));
            listClass.Add(new testClass("F", "G"));
            listClass.Add(new testClass("M", "N"));
            listClass.Add(new testClass("O", "N"));
            listClass.Add(new testClass("M", "P"));
            listClass.Add(new testClass("M", "Q"));
            int num = 0;
            foreach (var x in 分组(listClass))
            {
                Console.Write("第{0}组：", ++num);
                foreach (var y in x)
                    Console.Write("{0} ", y);
                Console.WriteLine();
            }
            Console.WriteLine("..............按任意键结束");
            Console.ReadKey();
        }
        private static IEnumerable<List<string>> 分组(List<testClass> listClass)
        {
            var 全部人 = (from x in listClass
                       select x.C1).Union(from x in listClass select x.C2);
            var 初始分组 = from x in 全部人 select new List<string> { x };   //先把每一个人独立做为一组
            foreach (var x in 合并(初始分组.ToList(), listClass))
                yield return x;
        }
        private static IEnumerable<List<string>> 合并(List<List<string>> 分组, List<testClass> 关系)
        {
            begin:
            if (分组.Count == 0)
                yield break;
            if (分组.Count == 1)
            {
                yield return 分组[0];
                yield break;
            }
            var first = 分组.First();
            var others = 分组.Skip(1);
            foreach (var x in others)
            {
                if (可以合并(first, x, 关系))
                {
                    x.AddRange(first);
                    分组 = others.ToList();
                    goto begin;         //减少一个分组之后，进行迭代
                }
            }
            yield return first;
            分组 = others.ToList();   //输出找到的一个分组，然后继续迭代剩下的分组
            goto begin;
        }
        private static bool 可以合并(List<string> x, List<string> y, List<testClass> 关系)
        {
            return (from a in x
                    from b in y
                    where 关系.Any(u => (u.C1 == a && u.C2 == b) || (u.C1 == b && u.C2 == a))
                    select a).Any();
        }
    }
}