C# में रिकर्सन का उपयोग करके क्विक सॉर्ट करना

क्विक सॉर्ट एक सॉर्टिंग एल्गोरिदम है जो विभाजन और विजय विधि का उपयोग करता है। यह एक पिवट तत्व लेता है और उसे उसकी सही स्थिति में रखता है। फिर पिवट तत्व के बाएं और दाएं की सरणी को फिर से क्विक सॉर्ट का उपयोग करके क्रमबद्ध किया जाता है। यह तब तक किया जाता है जब तक पूरी सरणी क्रमबद्ध नहीं हो जाती।

C# में रिकर्सन का उपयोग करके क्विक सॉर्ट को प्रदर्शित करने वाला एक प्रोग्राम निम्नलिखित है -

उदाहरण

using System; 
namespace QuickSortDemo { 
    class Example { 
        static public int Partition(int[] arr, int left, int right) { 
            int pivot; 
            pivot = arr[left]; 
            while (true) { 
                while (arr[left] < pivot) { 
                    left++; 
                } 
                while (arr[right] > pivot) { 
                    right--; 
                } 
                if (left < right) { 
                    int temp = arr[right]; 
                    arr[right] = arr[left]; 
                    arr[left] = temp; 
                } else { 
                    return right; 
                } 
            } 
        } 
        static public void quickSort(int[] arr, int left, int right) { 
            int pivot; 
            if (left < right) { 
                pivot = Partition(arr, left, right); 
                if (pivot > 1) { 
                    quickSort(arr, left, pivot - 1); 
                } 
                if (pivot + 1 < right) { 
                    quickSort(arr, pivot + 1, right); 
                } 
            } 
        } 
        static void Main(string[] args) { 
            int[] arr = {67, 12, 95, 56, 85, 1, 100, 23, 60, 9}; 
            int n = 10, i; 
            Console.WriteLine("क्विक सॉर्ट"); 
            Console.Write("प्रारंभिक सरणी है: "); 
            for (i = 0; i < n; i++) { 
                Console.Write(arr[i] + " "); 
            } 
            quickSort(arr, 0, 9); 
            Console.Write("\nक्रमबद्ध सरणी है: "); 
            for (i = 0; i < n; i++) { 
                Console.Write(arr[i] + " "); 
            } 
        } 
    } 
}

आउटपुट

उपरोक्त प्रोग्राम का आउटपुट निम्नलिखित है।

क्विक सॉर्ट 
प्रारंभिक सरणी है: 67 12 95 56 85 1 100 23 60 9 
क्रमबद्ध सरणी है: 1 9 12 23 56 60 67 85 95 100

अब आइए उपरोक्त प्रोग्राम को समझते हैं।

Main() फ़ंक्शन में, पहले प्रारंभिक सरणी प्रदर्शित की जाती है। फिर, सरणी पर क्विक सॉर्ट करने के लिए quickSort() फ़ंक्शन को कॉल किया जाता है। इसके लिए कोड स्निपेट निम्नलिखित है -

int[] arr = {67, 12, 95, 56, 85, 1, 100, 23, 60, 9}; 
int n = 10, i; 
Console.WriteLine("क्विक सॉर्ट"); 
Console.Write("प्रारंभिक सरणी है: "); 
for (i = 0; i < n; i++) { 
    Console.Write(arr[i] + " "); 
} 
quickSort(arr, 0, 9);

quickSort() फ़ंक्शन में, Partition() फ़ंक्शन को कॉल करके एक पिवट तत्व चुना जाता है। फिर quickSort() को फिर से उन आर्गुमेंट्स के साथ कॉल किया जाता है जो पिवट के मान पर निर्भर करते हैं। इसके लिए कोड स्निपेट निम्नलिखित है -

if (left < right) { 
    pivot = Partition(arr, left, right); 
    if (pivot > 1) { 
        quickSort(arr, left, pivot - 1); 
    } 
    if (pivot + 1 < right) { 
        quickSort(arr, pivot + 1, right); 
    } 
}

Partition() फ़ंक्शन में, पिवट तत्व को प्रदान की गई सरणी के बाएं सबसे तत्व के रूप में चुना जाता है और फिर इसे सरणी में इसकी सही स्थिति पर सेट किया जाता है। इसके सभी चरणों को प्रदर्शित करने वाला कोड स्निपेट निम्नलिखित है।

int pivot; 
pivot = arr[left]; 
while (true) { 
    while (arr[left] < pivot) { 
        left++; 
    } 
    while (arr[right] > pivot) { 
        right--; 
    } 
    if (left < right) { 
        int temp = arr[right]; 
        arr[right] = arr[left]; 
        arr[left] = temp; 
    } else { 
        return right; 
    } 
}