एक द्विआधारी खोज वृक्ष एक वर्तनी परीक्षक के रूप में उपयोग करते हुए

एक त्रिगुट पेड़ trie अधिक कुशल हो जाएगा

साथ ही सुझाव है / उपसर्ग खोज आप एक ऑटो क्या करने की जरूरत है, तो एक पेट्रीसिया पेड़ या मूलांक पेड़ को देख के लायक है।

उदाहरण आप दे दी है के साथ, प्रदर्शन, आप एक पूरी तरह से बेवकूफ एल्गोरिथ्म का उपयोग नहीं करते, बशर्ते अप्रासंगिक होने के लिए एक पीसी पर के बाद से पूरे आपरेशन समय यह उपयोगकर्ता को पहली बार परिणाम बताएंगे कि पढ़ने के लिए का लगभग 1% ले जाएगा संभावना है । लेकिन फिर भी, मैं मान लेंगे समस्या काफी बड़ा है कि प्रदर्शन एक मुद्दा है।

शब्दकोश फ़ाइल presorted तो है (के रूप में सबसे कर रहे हैं), और अगर पाठ शब्दकोश में छोटे रिश्तेदार है के रूप में आप का वर्णन है, तो मैं अत्यंत कष्ट पाठ सॉर्ट करने के लिए शायद डुप्लिकेट हटाने परीक्षा की जाएगी, और फिर दोनों सूचियों के माध्यम से पुनरावृति साइड-बाई साइड मर्ज प्रकार के रूप में एक ही प्रक्रिया का उपयोग कर, को छोड़कर आप रिपोर्ट है कि प्रत्येक पाठ शब्द के बजाय किसी मर्ज किए गए सूची outputting के शब्दकोश में है।

इस तरह के लिए M लॉग एम तुलना के बारे में में काम करता है, के साथ साथ यात्रा के लिए सबसे एन एम तुलना, पर (संभवतः कम है, लेकिन नहीं जटिलता-कम)। यही कारण है कि काफी एक बंद आपरेशन के लिए इष्टतम जटिलता के करीब है: एन में रेखीय अवधि आप तरीके बिल्कुल डिस्क से पूरे शब्दकोश पढ़ा नहीं करने के लिए खोजने की जरूरत से छुटकारा पाने के। मैं बहुत यकीन है कि यह फाइल में bsearch संभव है, विशेष रूप से यह देखते हुए कि शब्द काफी कम हैं, लेकिन छोटे N के लिए यह किसी की अनुमान है कि क्या वास्तव में जगह के बारे में मांग क्रमानुसार डेटा तक पहुँचने की तुलना में तेजी हो जाएगा।

यह निम्नलिखित विशेषताएं हैं:

• आप स्मृति में शब्दकोश, केवल पाठ आयोजित करने की जरूरत नहीं है।
• फिर भी, आप केवल शब्दकोश फ़ाइल पर एक पास हैं।
• आप शब्दकोश के किसी भी महंगा प्रसंस्करण नहीं करते हैं।

बेशक अगर शब्दकोश फ़ाइल पहले से पृथक नहीं किया जा रहा है तो यह काम नहीं करता है, और आप शब्दकोश अगले वर्तनी जाँच आपरेशन के लिए स्मृति में चारों ओर लटक रखने तो आप आई / ओ की लागत ऋण चुकाना सकते हैं और यह प्रसंस्करण में की जा सकता है अगर कई अलग अलग ग्रंथों भर में एक पेड़ है, जो लंबे समय में एक जीत हो जाएगा।

अगर शब्दकोश वास्तव में बहुत बड़ा है, तो आप अपनी भाषा में विभिन्न शब्दों के रिश्तेदार आवृत्तियों के अनुसार भारित एक असंतुलित पेड़ से एक पूर्व संसाधित प्रपत्र बराबर में डिस्क पर यह संग्रहीत करने से लाभ हो सकता है। तो फिर तुम छोटे ग्रंथों के लिए कम से कम हे (एन) डिस्क का उपयोग करते हैं, और सबसे OSs यह स्मृति में लोड करने से परेशान नहीं बिल्कुल, बस फ़ाइल mmap और इसके बारे में ओएस चिंता करते हैं पर कर सकते हैं। एक बड़े शब्दकोश के लिए, पूरे समूहों "डाइमिथाइल" के साथ शुरुआत शब्दों से युक्त छुआ की जरूरत कभी नहीं।

एक अन्य विचार शब्दकोश के लिए एक टेढ़ा पेड़ है। एक टेढ़ा पेड़ ही unbalances के रूप में आप चीजों को आदेश अक्सर इस्तेमाल मूल्यों जल्दी पता लगाने के लिए बनाने के लिए उस में देखो,। अधिकांश पाठ बार-बार शब्द की एक छोटी संख्या का उपयोग करता है, इसलिए यदि पाठ काफी लंबे समय भूमि के ऊपर का औचित्य साबित करने के लिए है यह अंततः जीत जाएगा।

उपरोक्त दोनों स्टीवन एक लोव मुद्दा यह है कि तार के लिए, एक Trie एक सामान्य पेड़ धड़कता के अधीन हैं। पता है कि क्या आप एक ऑफ-द-शेल्फ टेढ़ा trie, हालांकि मिल जाएगा मत करो।

तुम सिर्फ एक विशेष शब्द अपने शब्दकोश में मौजूद रहने पर देखने के लिए (अर्थात, यह की वर्तनी सही है) की कोशिश कर रहे हैं, तो मुझे नहीं लगता कि एक द्विआधारी खोज वृक्ष क्या आप के बाद कर रहे हैं है। उस जानकारी स्टोर करने के लिए एक बेहतर तरीका एक पेड़ शैली में किया जाएगा, जहां अपने पेड़ पर प्रत्येक उत्तरोत्तर नोड एक चरित्र है, और अंत नोड के लिए पथ पढ़ने आपको लगता है कि शब्द की वर्तनी देता है। तुम भी एक शब्द भी न खत्म होने वाली इंगित करने के लिए एक मार्कर जोड़ने की जरूरत होगी।

उदाहरण के लिए: मान लीजिए कि आपके शब्दकोश इन शब्दों है: कार, गाड़ी, बिल्ली, कप, कट

- C
  - A
    - R
      - end
      - T
    - T
      - end
  - U
    - P
      - end
    - T
      - end

यह देखना कि शब्द मौजूद प्रत्येक अक्षर पर व्यक्तिगत रूप से देख की बात है, और है कि यह वर्तमान नोड के बच्चों में मौजूद है।

Check for "cat"
Does "C" exist at the root level? Yes, move to the next letter.
Does "A" exist underneath C? Yes, move on.
Does "T" exist underneath A? Yes, move on.
Is there a word ending after the T? Yes. Word exists.

Check for "cu"
Does "C" exist at the root level? Yes, move to the next letter.
Does "U" exist at the root level? Yes, move to the next letter.
Is there a word ending after the U? No. Word does not exist.

आप कैसे संगृहीत इस जानकारी आप पर निर्भर है। स्टीवन के रूप में बताया, एक त्रिगुट खोजें Trie प्रत्येक नोड 27 संभव बच्चे नोड्स होगा: जाने का रास्ता हो सकता है।

आप एक द्विआधारी खोज वृक्ष के प्रयोग पर मृत सेट कर रहे हैं? एक ब्लूम फिल्टर शायद एक अधिक कुशल डेटा संरचना होगा।

यह देखते हुए कि यह एक होमवर्क सवाल मुझे लगता है कि आप एक सादे पुराने द्विआधारी पेड़ (कोई लाल काले पेड़ों, AVL पेड़, मूलांक पेड़, आदि) का उपयोग करना होगा जा रहा हूँ है। इस सवाल का जवाब तो के रूप में आप यह शब्द सूची से निर्माण पेड़ संतुलित रखने की कोशिश की जाती है। एक दृष्टिकोण पूर्व में इसे पढ़ने के लिए सूची randomize करने के लिए है, यह उचित परिणाम देता है। अगर आप इनपुट अनुक्रम (क्या पेड़ का उपयोग करता है के रूप में ही तुलना का उपयोग करके) के आदेश लेकिन आप बेहतर परिणाम प्राप्त कर सकते हैं, तो रिकर्सिवली मध्य लौटने तक कोई तत्व रहने के इनपुट पर उप-विभाजन। परिणाम एक संतुलित पेड़ है।

मैं सी # में यह कर के तीन अलग अलग तरीकों खटखटाया:

private static IEnumerable<T> BinaryTreeOrder<T>(IList<T> range, int first, int last)
{
  if (first > last)
  {
    yield break;
  }

  int mid = (first + last) / 2;
  yield return range[mid];
  foreach (var item in BinaryTreeOrder(range, first, mid - 1))
  {
    yield return item;
  }
  foreach (var item in BinaryTreeOrder(range, mid + 1, last))
  {
    yield return item;
  }    
}

private static void BinaryTreeOrder<T>(IList<T> range, int first, int last, 
                                       ref IList<T> outList)
{
  if (first > last)
  {
    return;
  }

  int mid = (first + last) / 2;
  outList.Add(range[mid]);
  BinaryTreeOrder(range, first, mid - 1, ref outList);
  BinaryTreeOrder(range, mid + 1, last, ref outList);
}

private static void BinaryTreeOrder<T>(IList<T> range, int first, int last, 
                                       ref BinaryTree<T> tree) where T : IComparable<T>
{
  if (first > last)
  {
    return;
  }

  int mid = (first + last) / 2;
  tree.Add(range[mid]);
  BinaryTreeOrder(range, first, mid - 1, ref tree);
  BinaryTreeOrder(range, mid + 1, last, ref tree);
}

इस साइट पर आप की मदद करनी चाहिए यह जावा में कार्यान्वयन है।

के रूप में सुझाव दिया एक Trie एक द्विआधारी पेड़ से अधिक कुशल हो सकता है, लेकिन आप एक hashmap का उपयोग करें और प्रत्येक शब्द हैश सकते। आप एक छोटे शब्दकोश (1000 प्रविष्टियों) है। आप अपने दस्तावेज़ पार के रूप में, तो देखें कि क्या शब्द hashmap में हैं। वे नहीं कर रहे हैं, शब्द गलत वर्तनी जा करने के लिए माना जाता है।

यह आपको एक गलत वर्तनी वाले शब्द के लिए संभव सुधार नहीं देंगे। यह सिर्फ आपको बताता है कि हाँ या ना (सही है या नहीं)।

आप गलत शब्दों के लिए वर्तनी सुझाव चाहते हैं तो आप फ़ाइल में शब्द से शुरू कर सकते हैं, तो सभी शब्द उत्पन्न 1 संपादित दूरी पर और प्रारंभिक शब्द के बच्चों के रूप में इन जोड़ें। इस तरह आप एक ग्राफ बना रहे हैं। 2 स्तर अधिकतम गति सटीकता बनाम के लिए गहरी जाओ। आप एक शब्द नोड शब्दकोश में है कि उत्पन्न हैं, तो आप यह संभव सुझावों की एक सूची के लिए जोड़ सकते हैं। अंत में, संभव सुझावों की सूची वापस जाएँ।

बेहतर वर्तनी जांच के लिए, यह भी ध्वन्यात्मक मिलान में जोड़ने के लिए प्रयास करें।

समुद्र yuh -> हाँ देखना

(तार के रेखांकन 1 संपादित दूर बनाने की) इस विधि "धीमी" है। लेकिन यह एक अच्छा शैक्षिक व्यायाम है। रनटाइम O (n ^ शाखाओं) है।

यदि एक करने के लिए यहाँ दिलचस्पी एक कड़ी है मैं अपने आप को बनाया (मनोरंजन के लिए): https://github.com/eamocanu/spellcheck.graph

कुछ नमूना रेखांकन: https://github.com/eamocanu/spellcheck.graph/tree/master/graph%20photos

मैं भी इसे करने के लिए एक UI घटक जोड़ा जो रेखांकन उत्पन्न करता है। यह एक बाहरी पुस्तकालय है।