#3 Sorting dan Searching
overview

#3 Sorting dan Searching

Umam Alfarizi Umam Alfarizi
September 5, 2025
3 min read
sorting-dan-searching

Masuk ke modul tiga! Kali ini kita bakal ngobrolin dua hal yang jadi tulang punggung banyak program: Sorting (mengurutkan) dan Searching (mencari). Kalau data kita rapi, nyarinya juga jadi gampang kan? Yuk, kita bedah satu per satu.

Sorting: Bikin Data Jadi Rapi

Sorting itu proses ngatur ulang data biar urut, bisa dari yang terkecil ke terbesar (ascending) atau sebaliknya (descending). Ada banyak banget algoritma sorting, tapi kita mulai dari dua yang paling dasar biar gampang ngertinya.

1. Bubble Sort

Ini algoritma sorting yang paling simpel. Gampangnya, bayangin gelembung udara di air, yang paling ringan bakal naik ke atas. Bubble sort bekerja dengan cara ngebandingin elemen sebelahan, terus dituker kalau urutannya salah. Proses ini diulang terus sampe nggak ada lagi yang perlu dituker.

public class SortingAlgorithms {
    public void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Tukar arr[j] dengan arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

Bubble sort ini gampang dipahami, tapi performanya kurang oke buat data yang jumlahnya jutaan.

2. Selection Sort

Kalau selection sort, logikanya sedikit beda. Algoritma ini bakal nyari elemen paling kecil di sisa data yang belum urut, terus dipindahin ke posisi paling depan. Gitu terus sampe semua datanya urut.

public class SortingAlgorithms {
    public void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // Tukar elemen terkecil ke posisi yang benar
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

Sama kayak Bubble Sort, algoritma ini juga simpel tapi kurang efisien untuk data skala besar.

Searching: Menemukan Jarum di Tumpukan Jerami

Setelah data kita urut, proses pencarian jadi jauh lebih gampang. Ada dua cara dasar buat nyari data.

Ini cara paling brutal dan paling gampang. Kita cek aja datanya satu per satu dari awal sampe akhir. Kalau ketemu, ya udah, berhenti. Kalau nggak ketemu sampe akhir, berarti emang nggak ada. Cara ini nggak peduli datanya urut atau acak.

public class SearchingAlgorithms {
    public int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i; // Mengembalikan indeks data yang ditemukan
            }
        }
        return -1; // Data tidak ditemukan
    }
}

Nah, ini cara yang jauh lebih cerdas dan cepat, tapi ada syaratnya: data harus sudah dalam keadaan terurut.

Logikanya kayak kita nyari nama di kamus. Kita buka tengah-tengah, terus kita liat, kata yang kita cari ada di sebelah kiri atau kanan? Kita buang setengah bagian yang salah, terus kita ulangi lagi di sisa setengahnya. Gitu terus sampe datanya ketemu.

public class SearchingAlgorithms {
    public int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;


        while (left <= right) {
            int mid = left + (right - left) / 2;


            if (arr[mid] == target) {
                return mid; // Data ditemukan
            }


            if (arr[mid] < target) {
                left = mid + 1; // Cari di setengah kanan
            } else {
                right = mid - 1; // Cari di setengah kiri
            }
        }
        return -1; // Data tidak ditemukan
    }
}

Binary search ini super cepat dibanding linear search, makanya sorting data itu penting banget.

Penutup Modul 3

Sekarang kita udah punya dua senjata dasar buat ngurutin dan nyari data. Walaupun algoritma yang kita pelajari ini simpel, tapi konsepnya jadi fondasi buat algoritma yang lebih canggih.

Di modul selanjutnya, kita bakal kenalan sama struktur data yang lebih kompleks dan non-linear, yaitu Tree. Sampai jumpa di sana!

Discussion