क्या पेड़ की संरचना या एल्गोरिदम एक पेड़ में चारों ओर घूमने के लिए है?

Question

मेरे पास एक दिलचस्प समस्या है जो मुझे लगता है।

असल में, मैं आइटम, जहां प्रत्येक मद विभिन्न मूल्यों की मेटा डेटा, का एक निश्चित सेट है की एक सूची है।

उदाहरण के लिए:

• आइटम 1: {type = "text", लेखक = "उपयोगकर्ता ए ', संपादित दिनांक =" 2003/03/03 "}
• आइटम 2: {प्रकार = "तालिका", लेखक = "उपयोगकर्ता ए ', संपादित दिनांक =" 2006/04/05 "}
• आइटम 3: {प्रकार =" छवि ", लेखक =" उपयोगकर्ता B ", संपादित दिनांक =" 05/05/2005 "}
• आइटम 4: {type =" text ", लेखक =" उपयोगकर्ता B ", संपादित दिनांक =" 2007/05/07 "}

अब, जैसा कि यह खड़ा है, वस्तुओं की सूची एक मेज में flattened और प्रस्तुत किया गया है।

हालांकि, हम उपयोगकर्ताओं को पेड़ में ब्राउज़ करने की अनुमति देने का एक तरीका खोजना चाहते हैं, लेकिन अतिरिक्त लचीलापन के साथ कि वे पेड़ में मेटा-डेटा टैग प्रत्येक ऑर्डर को 'पिवोट' कर सकते हैं।

तो, शुरू में यह दिख सकता है:

Items 
+ User A 
    + Text 
    + Table 
    -> Item 1 
    -> Item 2 
+ User B 
    + Image 
    + Text 
    -> Item 3 
    -> Item 4 

और इसलिए:

Items 
+ Table 
    + User A 
    + 04/05/2006 
     -> Item 2 
    -> Item 2 
    -> Item 2 
+ Text 
    + User A 
    + 03/03/2003 
     -> Item 1 
    -> Item 1 
    + User B 
    + 05/07/2007 
     -> Item 4 
    -> Item 4 
    -> Item 1 
    -> Item 4 
+ Image 
    .. 

हालांकि, बजाय लगता है, जब कोई उपयोगकर्ता इस दौर फ्लिप और एक विशेष उपयोगकर्ता से संबंधित सभी आइटम देखने के लिए करना चाहता है पर।

मुझे उम्मीद है कि यह समझ में आता है।

तो, मैं क्या सोच रहा हूं, क्या यह कम लागत पर इसे प्राप्त करने के लिए सबसे अच्छा अभ्यास दृष्टिकोण है? प्रत्येक 'फ्लिप/शफल/पिवट' का नतीजा अच्छी तरह से एक पेड़ में दर्शाया जाता है, इसलिए स्पष्ट रूप से पहला विचार यह है कि जब कोई उपयोगकर्ता प्रतिनिधित्व बदलने का अनुरोध करता है, तो आवश्यकतानुसार वस्तुओं की सूची का एक नया पेड़ उत्पन्न किया जा सकता है। हालांकि, मैं उम्मीद कर रहा था कि शायद एक बेहतर तरीका हो सकता है, बस एक पेड़ को घूर्णन करना आदि।

साथ ही, यह कुछ ऐसा है जो उपयोगकर्ता के ब्राउज़र पर जावास्क्रिप्ट में कम्प्यूटेशनल रूप से सस्ता रूप से किया जा सकता है, अगर बैकएंड बस वापस लौटना था वस्तुओं की एक फ्लैट सूची?

बहुत धन्यवाद & तरह सादर,

जेमी

Answer 1

वे जिस तरह से मैं चारों ओर हल करने के लिए इस सूची आइटम है कि कुछ इस तरह lookgs परिभाषित करने के लिए है जाना होगा:

public class Item 
{ 
    string NodeName {get; set;} 
    string Url {get; set;} 
    List<Item> Children {get; set;} 
} 

यह ग # है -कोड, लेकिन विचार किसी भी भाषा में लागू होना चाहिए जो वस्तुओं का समर्थन करता है। अब आपकी सूची को केवल एक प्रकार की सूची का समर्थन करने की आवश्यकता है, और यह Item की एक सूची है, इसलिए आपको बस इतना करना है कि आप अपने डेटा को ऐसी सूची में बदलने का तरीका ढूंढें।

Answer 2

आप एक वृक्ष संरचना में तत्वों प्रस्तुत करना चाहते हैं, लेकिन एक चर ट्री गहराई और बदलते पेड़ शाखाओं के साथ: मुझे शक है एक वृक्ष संरचना वास्तव में है कि आप क्या चाहते।

मुझे लगता है कि आपको इसके बजाय विचार करना चाहिए कि दुनिया फ्लैट है (आपकी तालिका में)। एक जावास्क्रिप्ट डेटाबेस मदद कर सकता है (वहाँ http://taffydb.com/ है)

फिर भी विचार दुनिया सपाट है, तो आप भी एक हस्ताक्षर समारोह है कि एक स्ट्रिंग रिटर्न

separator="µ"; //TODO Find something better 
function signature() { 
    return item.Type + separator + item.Author + separator + item.EditedDate; 
} 


assert(item1.signature == "TextµUser Aµ03/03/2003") 

तो आप इस का उपयोग कर एक साधारण शब्दकोश में अपनी वस्तुओं की दुकान बना सकते हैं कुंजी के रूप में हस्ताक्षर।

और फिर, आप अपनी इच्छित वस्तुओं को प्राप्त करने के लिए कुंजी पर एक regexp मिलान कर सकते हैं। सबसे पहले, हस्ताक्षर करने के लिए हस्ताक्षर फ़ंक्शन को संपादित करें "([^ विभाजक] +)" यदि संबंधित आइटम प्रॉपर्टी अपरिभाषित है।

assert ({Type="Text"}.signature() == "Textµ[^µ]+µ[^µ]+") 

function find(filterItem) { 
    retval= = new generic.list(); 
    for (var k in dict.keys()) { 
    if (k.match(regexp)) { 
     retval.add(dcit[k]); 
    } 
    } 
} 

मैं पता नहीं है कि क्या यह हालांकि सभी तत्वों को ब्राउज़ कर की तुलना में तेजी है।