Java Dizilerinden Verimli Tekrar Olanları Kaldırma

Bir diziden yinelenen elemanları verimli bir şekilde kaldırmak, programlamanın temel bir görevidir. Bu makale, her biri hız ve bellek kullanımı arasında farklı bir denge sunan üç farklı Java yaklaşımını ele almaktadır. Bu ödünleşimleri anlamak, belirli uygulamanız için en uygun yöntemi seçmek için çok önemlidir.

İçerik Tablosu

• Geçici Bir Dizi Kullanma
• Ayrı Bir İndeks Kullanma
• Arrays.sort() Metodunu Kullanma
• Metot Karşılaştırması

Geçici Bir Dizi Kullanma

Bu basit yöntem, giriş dizisi boyunca yineleme yapar. Her eleman, şimdiye kadar karşılaşılan yalnızca benzersiz elemanları içeren geçici bir diziyle karşılaştırılır. Bir eleman geçici dizide bulunmazsa, eklenir. Anlaşılması kolay olsa da, iç içe geçmiş döngü yapısı, büyük diziler için verimsiz hale getiren O(n²) zaman karmaşıklığını oluşturur.

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("Orijinal dizi: " + Arrays.toString(arr));
        System.out.println("Yinelenenler kaldırılmış dizi: " + Arrays.toString(uniqueArr));
    }
}

Zaman Karmaşıklığı: O(n²)
Alan Karmaşıklığı: O(n)

Ayrı Bir İndeks Kullanma

Bu yöntem, orijinal diziyi yerinde değiştirerek alan verimliliğini artırır. Bir sonraki benzersiz elemanın konumunu izlemek için ayrı bir indeks kullanır. Dizi yineletilir ve benzersiz elemanlar bu indeks tarafından gösterilen konumlara taşınır. Alan açısından verimli (O(1)) olsa da, iç içe geçmiş döngüler nedeniyle yine de O(n²) zaman karmaşıklığı çekmektedir.

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);
    }
    //main metodu yukarıdakiyle aynı kalır
}

Zaman Karmaşıklığı: O(n²)
Alan Karmaşıklığı: O(1)

Arrays.sort() Metodunu Kullanma

Bu yaklaşım, Java’nın yerleşik sıralama işlevselliğinden yararlanır. Dizinin önce sıralanması, yinelenen elemanları bir araya getirir. Sıralanmış diziden sonraki tek bir geçiş, yalnızca her elemanın ilk oluşumunu belirler ve korur. Zaman karmaşıklığı, sıralama algoritmasına (O(n log n)) hakimdir ve daha büyük veri kümeleri için önceki yöntemlerden önemli ölçüde daha iyi performans sunar.

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);
    }
    //main metodu yukarıdakiyle aynı kalır
}

Zaman Karmaşıklığı: O(n log n)
Alan Karmaşıklığı: O(n)

Metot Karşılaştırması

Yöntem seçimi, verilerinizin boyutuna ve önceliklerinize bağlıdır. Daha küçük diziler için, geçici dizi yönteminin basitliği yeterli olabilir. Daha büyük diziler için, Arrays.sort() yönteminin performans artışları, biraz daha yüksek alan karmaşıklığını ağır basmaktadır. Ayrı indeks yöntemi alan açısından verimli bir çözüm sunar, ancak kuadratik zaman karmaşıklığı, büyük veri kümeleri için daha az çekici hale getirir.