Java सरणियों से कुशल डुप्लीकेट निष्कासन

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

विषयवस्तु की तालिका

• एक अस्थायी सरणी का उपयोग करना
• एक अलग सूचकांक का उपयोग करना
• Arrays.sort() विधि का उपयोग करना
• विधि तुलना

एक अस्थायी सरणी का उपयोग करना

यह सरल विधि इनपुट सरणी के माध्यम से पुनरावृति करती है। प्रत्येक तत्व को केवल अब तक सामने आए अद्वितीय तत्वों वाले एक अस्थायी सरणी के विरुद्ध जाँचा जाता है। यदि कोई तत्व अस्थायी सरणी में नहीं पाया जाता है, तो उसे जोड़ा जाता है। हालांकि समझने में आसान है, इसकी नेस्टेड लूप संरचना O(n²) की समय जटिलता की ओर ले जाती है, जिससे यह बड़े सरणियों के लिए अकुशल हो जाता है।

import java.util.Arrays;

public class RemoveDuplicates {

    public static int[] removeDuplicatesTempArray(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0]; 
        }

        int[] uniqueArr = new int[arr.length]; 
        int uniqueCount = 0;

        for (int i = 0; i < arr.length; i++) {
            boolean isDuplicate = false;
            for (int j = 0; j < uniqueCount; j++) {
                if (arr[i] == uniqueArr[j]) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                uniqueArr[uniqueCount++] = arr[i];
            }
        }

        return Arrays.copyOf(uniqueArr, uniqueCount); 
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 4, 4, 5, 5, 5};
        int[] uniqueArr = removeDuplicatesTempArray(arr);
        System.out.println("मूल सरणी: " + Arrays.toString(arr));
        System.out.println("डुप्लीकेट हटाने के साथ सरणी: " + Arrays.toString(uniqueArr));
    }
}

समय जटिलता: O(n²)
स्थान जटिलता: O(n)

एक अलग सूचकांक का उपयोग करना

यह विधि मूल सरणी को स्थान पर संशोधित करके स्थान दक्षता में सुधार करती है। यह अगले अद्वितीय तत्व की स्थिति को ट्रैक करने के लिए एक अलग सूचकांक का उपयोग करता है। सरणी को पुनरावृति किया जाता है, और अद्वितीय तत्वों को इस सूचकांक द्वारा इंगित स्थितियों में ले जाया जाता है। जबकि स्थान-कुशल (O(1)), यह अभी भी नेस्टेड लूप्स के कारण O(n²) समय जटिलता से ग्रस्त है।

public class RemoveDuplicates {

    public static int[] removeDuplicatesIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0];
        }

        int index = 1; 
        for (int i = 1; i < arr.length; i++) {
            boolean isDuplicate = false;
            for (int j = 0; j < index; j++) {
                if (arr[i] == arr[j]) {
                    isDuplicate = true;
                    break;
                }
            }
            if (!isDuplicate) {
                arr[index++] = arr[i];
            }
        }
        return Arrays.copyOf(arr, index);
    }
    //ऊपर जैसा ही मुख्य मेथड
}

समय जटिलता: O(n²)
स्थान जटिलता: O(1)

Arrays.sort() विधि का उपयोग करना

यह दृष्टिकोण जावा की अंतर्निहित सॉर्टिंग कार्यक्षमता का लाभ उठाता है। सरणी को पहले क्रमबद्ध करना डुप्लीकेट तत्वों को एक साथ लाता है। क्रमबद्ध सरणी के माध्यम से बाद के एकल पास प्रत्येक तत्व के केवल पहले प्रकट होने की पहचान करता है और उसे बनाए रखता है। समय जटिलता सॉर्टिंग एल्गोरिथम (O(n log n)) द्वारा नियंत्रित होती है, जो पिछली विधियों की तुलना में बड़े डेटासेट के लिए काफी बेहतर प्रदर्शन प्रदान करती है।

import java.util.Arrays;

public class RemoveDuplicates {

    public static int[] removeDuplicatesSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0];
        }

        Arrays.sort(arr); 
        int[] uniqueArr = new int[arr.length];
        uniqueArr[0] = arr[0]; 
        int uniqueCount = 1;

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] != arr[i - 1]) {
                uniqueArr[uniqueCount++] = arr[i];
            }
        }

        return Arrays.copyOf(uniqueArr, uniqueCount);
    }
    //ऊपर जैसा ही मुख्य मेथड
}

समय जटिलता: O(n log n)
स्थान जटिलता: O(n)

विधि तुलना

विधि का चुनाव आपके डेटा के आकार और आपकी प्राथमिकताओं पर निर्भर करता है। छोटे सरणियों के लिए, अस्थायी सरणी विधि की सादगी पर्याप्त हो सकती है। बड़े सरणियों के लिए, Arrays.sort() विधि के प्रदर्शन लाभ इसकी थोड़ी अधिक स्थान जटिलता से अधिक हैं। अलग सूचकांक विधि एक स्थान-कुशल समाधान प्रदान करती है, लेकिन इसकी द्विघातीय समय जटिलता इसे बड़े डेटासेट के लिए कम आकर्षक बनाती है।