2013-07-11 4 views
7

मैं डेटा संरचनाओं की एक सूची है:ऑब्जेक्ट का उपयोग करने के लिए लिंक के साथ पदानुक्रम कैसे बनाया जाए?

 public List<Personal> Personals() 
     { 
      return new List<Personal> 
       { 
        new Personal 
         { 
          Id = 0, 
          Name = "Name 0" 
         }, 
        new Personal 
         { 
          Id = 1, 
          Name = "Name 1", 
          ParentId = 0 
         }, 
        new Personal 
         { 
          Id = 2, 
          Name = "Name 2", 
          ParentId = 0 
         }, 
        new Personal 
         { 
          Id = 3, 
          Name = "Name 3", 
          ParentId = 0 
         }, 
        new Personal 
         { 
          Id = 4, 
          Name = "Name 4", 
          ParentId = 1 
         }, 
        new Personal 
         { 
          Id = 5, 
          Name = "Name 5", 
          ParentId = 1 
         }, 
        new Personal 
         { 
          Id = 6, 
          Name = "Name 6", 
          ParentId = 2 
         }, 
        new Personal 
         { 
          Id = 7, 
          Name = "Name 7", 
          ParentId = 2 
         }, 
        new Personal 
         { 
          Id = 8, 
          Name = "Name 8", 
          ParentId = 4 
         }, 
        new Personal 
         { 
          Id = 9, 
          Name = "Name 9", 
          ParentId = 4 
         }, 
       }; 
     } 

और मैं एक पेड़ का निर्माण करना चाहते:

public List<Tree> Trees() 
      { 
       return new List<Tree> 
        { 
         new Tree 
          { 
           Id = 0, 
           Name = "Name 0", 
           List = new List<Tree> 
            { 
             new Tree 
              { 
               Id = 1, 
               Name = "Name 1", 
               List = new List<Tree> 
                { 
                 new Tree 
                  { 
                   Id = 4, 
                   Name = "Name 4" 
                  }, 
                 new Tree 
                  { 
                   Id = 5, 
                   Name = "Name 5" 
                  } 
                } 
              } 
            } 
          } 
        }; 
      } 

कैसे आप आपत्ति उठाने LinQ के साथ एक पेड़ का निर्माण करते हैं? मैं उपयोग करने के लिए है, लेकिन यह वास्तव में काम नहीं करता है, नीचे देखें: यदि आपके रूट नोड एक है के लिए केवल इस कोड की जाँच करता ऊपर के रूप में

public void SomeMethod() { 
    // here you get your `list` 
    var tree = GetTree(list, 0); 
} 

public List<Tree> GetTree(List<Personal> list, int parent) { 
    return list.Where(x => x.ParentId == parent).Select(x => new Tree { 
     Id = x.Id, 
     Name = x.Name, 
     List = GetTree(list, x.Id) 
    }).ToList(); 
} 
+0

यदि आप जेनेरिक प्रकार के उपयोग के साथ एक पेड़ बनाना चाहते हैं, तो कृपया अपने उदाहरण साझा करें। धन्यवाद! – LazyCatIT

उत्तर

15

आप प्रत्यावर्तन का उपयोग करना चाहिए अभिभावक जो अपनी आईडी से मेल खाता है।

public void SomeMethod() 
    { 
     // here you get your `list` 
     var tree = GetTree(list, 0); 
    } 

    public List<Tree> GetTree(List<Personal> list, int parent) 
    { 
     return list.Where(x => x.ParentId == parent).Select(x => new Tree 
     { 
      Id = x.Id, 
      Name = x.Name, 
      List = x.ParentId != x.Id ? GetTree(list, x.Id) : new List<Tree>() 
     }).ToList(); 
    } 
+0

आपके उत्तर के लिए धन्यवाद! लेकिन जब मैं आपका कोड लागू करता हूं, तो यह एक अपवाद "सिस्टम। स्टैक ओवरफ्लो एक्सेप्शन" बढ़ाता है। आप इसे फिर से देख सकते हैं। – LazyCatIT

+2

यदि आपके पास चक्रीय लिंक के साथ 'सूची' में कोई आइटम है तो ऐसा हो सकता है। उदाहरण के लिए: [{{आईडी = 1, ParentId = 2}, {आईडी = 2, ParentId = 1}] (http://en.wikipedia.org/wiki/Cycle_graph) – YD1m

+0

मामले को संभालने के लिए नीचे एक ट्वीक जोड़ा गया किसी के पास ParentId = Id –

0

ही:

public List<Tree> GetTree(List<Personal> list) 
     { 
      var listFormat = list.Select(x => new Tree 
       { 
        Id = x.Id, 
        Name = x.Name, 
        ParentId = x.ParentId 
       }).ToList(); 

      var lookup = listFormat.ToLookup(f => f.ParentId); 
      foreach (var tree in listFormat) 
      { 
       tree.List = lookup[tree.Id].ToList(); 
      } 

      return listFormat; 
     } 
+1

के साथ रूट नोड है, यह केवल उस मामले का पता लगाएगा जिसमें 2 नोड्स माता-पिता (# 1 -> # 2 -> # 1 -> आदि) के रूप में एक-दूसरे को सीधे संदर्भित करते हैं। यदि आप एक तीसरा नोड (# 1 -> # 2 -> # 3 -> # 1 -> आदि) पेश करते हैं, तो चक्र एक बार फिर से अपना सिर पीछे रखेगा। – BTownTKD

संबंधित मुद्दे