2016-06-22 5 views
12

कई उदाहरण के बराबर होती है के बारे में quicksort (जावा में) इस के करीब हैं:quicksort - के लिए कारण की जाँच करता वेब पर

private void quicksort(int low, int high) { 
    int i = low, j = high; 
    int pivot = numbers[low + (high-low)/2]; 

    while (i <= j) { 

     while (numbers[i] < pivot) { 
     i++; 
     } 

     while (numbers[j] > pivot) { 
     j--; 
     } 

     if (i <= j) { 
     exchange(i, j); 
     i++; 
     j--; 
     } 
    } 

    if (low < j) 
     quicksort(low, j); 
    if (i < high) 
     quicksort(i, high); 
} 

बात मैं के बारे में है हैरान हूँ क्यों उन चेकों के बराबर होती है इस प्रकार हैं:

1) while (i <= j) बजाय while (i < j)

2) if (i <= j) बजाय if (i < j)

क्या कोई बढ़िया मामला है जहां यह बराबर महत्वपूर्ण है? मेरी समझ से अगर हम if(i == j) होता है, तो हम मूल रूप से एक ही मूल्य के समान मूल्य वाली का आदान-प्रदान करेंगे।

किसी मेरे लिए है कि पहेली को हल कर सकते हैं?

+0

आप इस तरह कोड होने उन ऑनलाइन स्रोत में से एक के एक लिंक पोस्ट कर सकते हैं? मुझे लगता है कि आप सही है कि यह एक ही तत्व – shole

+0

वास्तव में ऊपर से टुकड़ा vogella ब्लॉग से आता है के साथ स्वैप करने के लिए काफी व्यर्थ है कर रहे हैं। – Lucas

उत्तर

6

मान लीजिए कि हालत i < j ने ले ली है।

5,4,3,2,1 

जबकि पाश i = 2 और j = 2, और हम ओवरलैपिंग कॉल quicksort ढंग से काम करने के लिए होगा के साथ समाप्त होता है और इन कॉल होगा::

देखो क्या की तरह एक सरणी के लिए क्या होगा चलें

quicksort(0,2) and quicksort(2,4) 

जबकि अगर हमारे पास यह स्थिति i<=j है तो लूप i = 4 और j = 1 के साथ समाप्त हो जाएगा और अब हम wou

quicksort(0,1) and quicksort(3,4) 

जो सही कॉल कर रहे हैं: ld के रूप में कॉल नहीं है।

तो बुनियादी तौर पर आप ठीक वहीं पर एक ही तत्व लेकिन कोड के लेखक की अदला-बदली करने का कोई मतलब यह एक अतिरिक्त शर्त यह है कि आप स्वैप करने के लिए जब मैं जे

के बराबर होती है की आवश्यकता नहीं है जोड़ने के लिए की जरूरत से बचने के लिए छोड़ दी हैं चाहिए रहे हैं
+0

मैं देखता हूं। यह वास्तव में "2" इंडेक्स को ओवरलैप करेगा, लेकिन अंत में एल्गोरिदम तोड़ नहीं देगा? क्या आप मुझे बताएंगे कि आपने उपरोक्त कोड से <= मामलों को छोड़ दिया है? – Lucas

+0

हां यह निश्चित रूप से एल्गोरिदम तोड़ता है यदि हमारे पास <<के बजाय <= है क्योंकि quicksort विभाजन सरणी को ओवरलैप करने के लिए दो अलग-अलग उपरोक्त में सरणी को विभाजित करता है। –

+0

@ लुकास एकमात्र चीज जो मैं करूँगा वह स्वैपिंग के लिए शर्त जोड़ती है। मतलब मैं केवल तभी स्वैप करूँगा जब मैं! = जे। –

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