KATA PENGANTAR

Puji syukur ke hadirat Tuhan Yang Maha Esa yang telah melimpahkan rahmat dan
karunia-Nya, sehingga kami dapat menyelesaikan makalah yang berjudul "Sorting
dan Searching: Konsep dan Implementasi Algoritma" ini tepat pada waktunya.
Makalah ini disusun sebagai salah satu bentuk tugas untuk memahami konsep dan
implementasi algoritma Sorting dan Searching, yang memiliki peranan penting dalam
bidang pemrograman dan pengolahan data. Kami berharap makalah ini dapat
memberikan wawasan bagi pembaca mengenai pentingnya efisiensi algoritma dalam
pengelolaan data.
Kami menyadari bahwa makalah ini masih jauh dari sempurna. Oleh karena itu,
kami dengan senang hati menerima kritik dan saran dari berbagai pihak untuk
memperbaiki dan menyempurnakan karya ini di masa mendatang.
Pada kesempatan ini, kami juga mengucapkan terima kasih kepada semua pihak
yang telah memberikan bantuan, baik berupa dukungan moral maupun material,
sehingga makalah ini dapat terselesaikan dengan baik.
Semoga makalah ini dapat memberikan manfaat dan menambah wawasan bagi
pembaca, khususnya dalam bidang algoritma dan struktur data.

DAFTAR ISI

1
KATA PENGANTAR....................................................................................................1
DAFTAR ISI..................................................................................................................2
BAB I.............................................................................................................................4
1.1 LATAR BELAKANG..........................................................................................4
1.2 RUMUSAN MASALAH.....................................................................................5
1.3 TUJUAN PENULISAN.......................................................................................5
1.4 MANFAAT PENULISAN...................................................................................6
BAB II...........................................................................................................................7
LANDASAN TEORI....................................................................................................7
2.1 PENGENALAN SORTING DAN SEARCHING...............................................7
2.2 PENTINGNYA SORTING DAN SEARCHING DALAM PEMROGRAMAN.8
2.3 ALGORITMA DAN KOMPLEKSITAS WAKTU............................................10
BAB III........................................................................................................................14
IMPLEMENTASI SORTING DALAM BAHASA C.................................................14
3.1 BUBBLE SORT.................................................................................................14
Output Program:...................................................................................................15
3.2 SELECTION SORT...........................................................................................16
3.3 INSERTION SORT............................................................................................18
Output Program:...................................................................................................19
3.4 MERGE SORT...................................................................................................20
Output Program:...................................................................................................23
3.5 QUICK SORT....................................................................................................23
Output Program:...................................................................................................26
3.6 PERBANDINGAN DAN EFISIENSI SORTING.............................................26
BAB IV........................................................................................................................30
IMPLEMENTASI SEARCHING DALAM BAHASA C...........................................30
4.1 LINEAR SEARCH............................................................................................30
Output Program:...................................................................................................32
4.2 BINARY SEARCH............................................................................................32
Output Program:...................................................................................................35

2
 4.3 IMPLEMENTASI PADA DATA ARRAY.........................................................35
4.4 STUDI KASUS DAN ANALISIS EFISIENSI.................................................38
BAB VI........................................................................................................................42
KESIMPULAN DAN SARAN...................................................................................42
6.1 KESIMPULAN..................................................................................................42
6.2 SARAN..............................................................................................................43
6.3 DAFTAR PUSTAKA.........................................................................................45

BAB I
PENDAHULUAN

3
1.1 LATAR BELAKANG
Sorting (pengurutan) dan searching (pencarian) adalah dua konsep dasar dalam
ilmu komputer yang memiliki peran penting dalam pengelolaan dan manipulasi data.
Kedua konsep ini menjadi pondasi bagi berbagai algoritma dan aplikasi dalam
pemrograman, termasuk dalam bahasa C.
Sorting
Sorting adalah proses mengatur elemen data dalam suatu urutan tertentu, seperti
urutan menaik (ascending) atau menurun (descending). Teknik pengurutan sangat
penting untuk meningkatkan efisiensi dalam pengolahan data, seperti pencarian data,
penghapusan duplikasi, dan analisis data. Dalam bahasa C, terdapat berbagai
algoritma sorting yang dapat diimplementasikan, di antaranya:
 Bubble Sort: Algoritma sederhana yang membandingkan elemen berdekatan
dan menukarnya jika tidak sesuai urutan.
 Selection Sort: Algoritma yang memilih elemen terkecil atau terbesar dari
daftar dan menempatkannya di posisi yang sesuai.
 Quick Sort: Salah satu algoritma yang sangat efisien dengan teknik divide-
and-conquer.
 Merge Sort: Menggabungkan dua subarray yang telah diurutkan
menggunakan pendekatan rekursif.
Searching
Searching adalah proses menemukan data tertentu dalam kumpulan data
berdasarkan kriteria tertentu. Algoritma searching yang efisien membantu
mempercepat pengambilan informasi dari basis data atau struktur data.
Contoh algoritma searching dalam bahasa C meliputi:
 Linear Search: Metode sederhana yang memeriksa elemen satu per satu
hingga menemukan data yang dicari.
 Binary Search: Algoritma yang lebih cepat tetapi hanya dapat digunakan pada
data yang sudah terurut, dengan membagi ruang pencarian menjadi dua setiap
kali.
 Hashing: Teknik pencarian yang menggunakan struktur data hash untuk
menemukan elemen secara langsung.
Pentingnya Sorting dan Searching
Dalam dunia nyata, sorting dan searching sering diterapkan pada berbagai
aplikasi, seperti:

1. Database: Untuk pengelolaan data yang efisien.

4
 2. Pencarian Internet: Mesin pencari menggunakan algoritma searching untuk
menemukan informasi dengan cepat.
3. E-commerce: Mengurutkan barang berdasarkan harga, popularitas, atau
relevansi.
Implementasi sorting dan searching dalam bahasa C melibatkan pemahaman
tentang struktur data seperti array, pointer, dan rekursi, yang menjadikannya
alat penting bagi pengembang perangkat lunak untuk memproses data secara
efisien.

1.2 RUMUSAN MASALAH

Berdasarkan latar belakang yang telah dijelaskan, maka rumusan masalah yang
dapat dirumuskan adalah sebagai berikut:
 Bagaimana cara mengimplementasikan algoritma sorting dan searching
menggunakan bahasa C?
 Apa saja perbedaan antara berbagai jenis algoritma sorting (seperti Bubble
Sort, Quick Sort, dan Merge Sort) dalam hal efisiensi dan kompleksitasnya?
 Bagaimana efisiensi algoritma searching (Linear Search dan Binary Search)
dibandingkan berdasarkan kondisi dan ukuran data?
 Apa faktor-faktor yang mempengaruhi pemilihan algoritma sorting dan
searching yang paling sesuai untuk suatu kasus tertentu?
 Bagaimana cara mengoptimalkan proses sorting dan searching untuk
meningkatkan performa dalam pengolahan data?
Rumusan masalah ini bertujuan untuk memberikan arah penelitian dan eksplorasi
dalam memahami serta menerapkan algoritma sorting dan searching secara optimal
menggunakan bahasa C.

1.3 TUJUAN PENULISAN

 Menjelaskan implementasi algoritma sorting dan searching menggunakan
bahasa C.
 Menganalisis perbedaan efisiensi dan kompleksitas berbagai algoritma
sorting, seperti Bubble Sort, Quick Sort, dan Merge Sort.
 Mengevaluasi kinerja algoritma searching, seperti Linear Search dan Binary
Search, berdasarkan kondisi data yang berbeda.
 Mengidentifikasi faktor-faktor yang memengaruhi pemilihan algoritma
sorting dan searching yang paling sesuai untuk suatu masalah.

5
  Memberikan pemahaman tentang cara mengoptimalkan proses sorting dan
searching untuk meningkatkan efisiensi dalam pengolahan data.
 Tujuan ini diharapkan dapat membantu pembaca memahami dan menerapkan
algoritma sorting dan searching dengan tepat dalam pemrograman
menggunakan bahasa C.

1.4 MANFAAT PENULISAN

 Manfaat Akademis:
Membantu mahasiswa atau pembelajar dalam memahami konsep dasar algoritma
sorting dan searching serta penerapannya dalam bahasa C.
 Manfaat Praktis:
Memberikan panduan kepada pengembang perangkat lunak dalam memilih dan
mengimplementasikan algoritma sorting dan searching yang efisien sesuai
kebutuhan.
 Manfaat Penelitian:
Menyediakan dasar pengetahuan yang dapat dijadikan referensi untuk penelitian
lebih lanjut mengenai optimalisasi algoritma sorting dan searching.
 Manfaat Aplikasi:
Meningkatkan kemampuan pengelolaan data dalam aplikasi nyata, seperti
database, mesin pencari, dan sistem berbasis data lainnya.
Dengan manfaat ini, diharapkan penulisan ini dapat memberikan kontribusi yang
signifikan dalam pengembangan keterampilan dan pengetahuan di bidang algoritma
komputer.

6
 BAB II

LANDASAN TEORI
2.1 PENGENALAN SORTING DAN SEARCHING
Sorting (pengurutan) dan searching (pencarian) adalah dua konsep fundamental
dalam ilmu komputer yang sering digunakan untuk mengelola dan memproses data.
Keduanya memainkan peran penting dalam berbagai aplikasi mulai dari sistem basis
data hingga kecerdasan buatan.
1. Sorting (Pengurutan)
Sorting adalah proses mengatur data dalam suatu urutan tertentu, baik secara
menaik (ascending) maupun menurun (descending). Proses ini mempermudah
pengolahan data, seperti pencarian, pengelompokan, dan analisis.
 Tujuan Sorting:
Mengatur data agar lebih terstruktur dan memudahkan pengambilan
informasi.
 Contoh Penggunaan Sorting:
Dalam e-commerce, barang diurutkan berdasarkan harga, popularitas, atau
ulasan pelanggan.
Beberapa algoritma sorting umum meliputi:
1. Bubble Sort: Algoritma sederhana yang membandingkan dan menukar elemen
yang tidak sesuai urutan.
2. Insertion Sort: Memasukkan elemen ke dalam posisi yang benar pada daftar
yang sudah terurut.
3. Quick Sort: Menggunakan pendekatan divide and conquer untuk membagi
data menjadi sub-kelompok kecil.
4. Merge Sort: Menggabungkan dua subarray terurut menjadi satu array terurut.
2. Searching (Pencarian)
Searching adalah proses menemukan elemen tertentu dalam kumpulan data.
Teknik pencarian yang efisien sangat penting untuk mempercepat proses pengambilan
data.

7
  Tujuan Searching:
Mengambil informasi yang spesifik dari data yang besar.
 Contoh Penggunaan Searching
Dalam mesin pencari, menemukan hasil yang relevan dari kata kunci pengguna.
Beberapa algoritma searching populer meliputi:
1. Linear Search: Memeriksa elemen satu per satu hingga elemen yang dicari
ditemukan.
2. Binary Search: Membagi ruang pencarian menjadi dua pada setiap langkah
untuk menemukan elemen. (Hanya bisa digunakan pada data yang sudah
terurut.)
3. Hashing: Menggunakan struktur data hash untuk pencarian cepat berdasarkan
kunci tertentu.
Keterkaitan Sorting dan Searching
Sorting sering kali menjadi langkah awal yang diperlukan untuk meningkatkan
efisiensi algoritma searching. Sebagai contoh, Binary Search hanya bisa dilakukan
pada data yang sudah terurut, sehingga sorting menjadi prasyaratnya.
Dengan pemahaman mendalam tentang sorting dan searching, pengembang
perangkat lunak dapat mengolah data dengan cara yang lebih cepat dan efisien, baik
dalam skala kecil maupun besar.

2.2 PENTINGNYA SORTING DAN SEARCHING DALAM PEMROGRAMAN

Sorting (pengurutan) dan searching (pencarian) adalah dua konsep utama dalam
pemrograman yang memiliki dampak signifikan pada efisiensi dan efektivitas
pengolahan data. Keduanya menjadi landasan bagi banyak algoritma dan aplikasi
yang digunakan dalam berbagai bidang teknologi. Berikut adalah alasan mengapa
sorting dan searching sangat penting dalam pemrograman:
1. Mempermudah Akses Data
Sorting membantu mengatur data dalam urutan tertentu, sehingga memudahkan
pengguna untuk menemukan elemen yang dibutuhkan. Dengan data yang terurut,

8
proses pencarian menjadi lebih sederhana dan cepat, terutama jika menggunakan
algoritma seperti Binary Search.

2. Meningkatkan Efisiensi Algoritma

Algoritma yang melibatkan pengolahan data dalam jumlah besar, seperti
pencarian, penghitungan statistik, atau pengelompokan data, akan lebih efisien jika
data telah diurutkan. Sebagai contoh, dalam aplikasi database, pengurutan data
memungkinkan pengambilan informasi dengan waktu pemrosesan yang lebih singkat.
3. Aplikasi dalam Dunia Nyata
Sorting dan searching banyak digunakan dalam aplikasi sehari-hari, seperti:
 E-commerce: Mengurutkan produk berdasarkan harga, ulasan, atau
popularitas.
 Sistem Basis Data: Mempercepat pencarian data pelanggan atau catatan
transaksi.
 Pemrosesan Dokumen: Mencari kata atau frase tertentu dalam dokumen besar.
 Pemrosesan Gambar dan Video: Mencari objek tertentu dalam kumpulan data
multimedia.
4. Fondasi untuk Algoritma Lanjutan
Sorting dan searching adalah dasar untuk algoritma yang lebih kompleks, seperti
algoritma graf, data mining, dan machine learning. Banyak algoritma ini memerlukan
data yang terstruktur atau kemampuan untuk menemukan informasi tertentu dengan
cepat.
5. Optimalisasi Sumber Daya Komputasi
Pemilihan algoritma sorting dan searching yang sesuai dapat mengurangi
penggunaan memori dan waktu eksekusi program. Misalnya, penggunaan Quick Sort
dalam kasus besar lebih efisien dibandingkan Bubble Sort, sementara Binary Search
lebih cepat dibandingkan Linear Search untuk data yang terurut.
6. Meningkatkan Kinerja Aplikasi
Efisiensi sorting dan searching berdampak langsung pada kinerja aplikasi. Dalam
sistem dengan volume data yang besar, seperti pencarian web atau analisis data besar

9
(big data), kemampuan untuk mengelola data dengan cepat adalah hal yang sangat
penting.
Dengan memahami dan menerapkan algoritma sorting dan searching secara
efektif, pengembang dapat menciptakan program yang lebih cepat, efisien, dan andal
untuk berbagai kebutuhan komputasi.

2.3 ALGORITMA DAN KOMPLEKSITAS WAKTU

Setiap algoritma memiliki cara kerja yang berbeda dalam menyelesaikan suatu
masalah, dan efisiensi algoritma tersebut biasanya diukur dengan kompleksitas waktu
(time complexity). Kompleksitas waktu menggambarkan seberapa banyak waktu yang
dibutuhkan algoritma untuk menyelesaikan suatu proses berdasarkan ukuran input
data (n).
Berikut adalah beberapa algoritma sorting dan searching beserta analisis kompleksitas
waktunya:

A. Sorting (Pengurutan)
1. Bubble Sort
o Cara Kerja: Membandingkan elemen yang berdekatan dan menukar
posisi jika elemen tidak sesuai urutan.
o Kompleksitas Waktu:
 Kasus terbaik: O(n)O(n)O(n) (saat data sudah terurut).
 Kasus rata-rata: O(n2)O(n^2)O(n2).
 Kasus terburuk: O(n2)O(n^2)O(n2).
o Kelebihan: Implementasi sederhana.
o Kekurangan: Tidak efisien untuk dataset besar.
2. Selection Sort
o Cara Kerja: Memilih elemen terkecil dari daftar yang belum terurut,
lalu menukarnya dengan elemen di posisi awal.
o Kompleksitas Waktu:
 Kasus terbaik, rata-rata, dan terburuk: O(n2)O(n^2)O(n2).

10
 o Kelebihan: Mudah dipahami.
o Kekurangan: Lambat untuk dataset besar.

3. Quick Sort
o Cara Kerja: Memilih elemen pivot, lalu membagi data menjadi dua
subarray berdasarkan pivot.
o Kompleksitas Waktu:
 Kasus terbaik dan rata-rata: O(nlog⁡n)O(n \log n)O(nlogn).
 Kasus terburuk: O(n2)O(n^2)O(n2) (jika pivot dipilih buruk).
o Kelebihan: Sangat cepat untuk dataset besar.
o Kekurangan: Sensitif terhadap pemilihan pivot.
4. Merge Sort
o Cara Kerja: Membagi data menjadi subarray kecil, mengurutkan setiap
subarray, dan menggabungkannya kembali.
o Kompleksitas Waktu:
 Semua kasus: O(nlog⁡n)O(n \log n)O(nlogn).
o Kelebihan: Stabil dan efisien untuk data besar.
o Kekurangan: Memerlukan ruang memori tambahan.

B. Searching (Pencarian)
1. Linear Search
o Cara Kerja: Memeriksa setiap elemen satu per satu hingga menemukan
elemen yang dicari.
o Kompleksitas Waktu:
 Kasus terbaik: O(1)O(1)O(1) (elemen ditemukan di awal).
 Kasus rata-rata dan terburuk: O(n)O(n)O(n).

11
 o Kelebihan: Mudah diimplementasikan.
o Kekurangan: Lambat untuk dataset besar.

2. Binary Search
o Cara Kerja: Membagi ruang pencarian menjadi dua pada setiap
langkah. (Data harus terurut.)
o Kompleksitas Waktu:
 Semua kasus: O(log⁡n)O(\log n)O(logn).
o Kelebihan: Sangat cepat untuk data terurut.
o Kekurangan: Hanya dapat digunakan pada data yang telah diurutkan.
3. Hashing
o Cara Kerja: Menggunakan fungsi hash untuk menentukan posisi
elemen dalam struktur data.
o Kompleksitas Waktu:
 Kasus terbaik: O(1)O(1)O(1).
 Kasus terburuk: O(n)O(n)O(n) (jika terjadi collision).
o Kelebihan: Cepat untuk pencarian langsung.
o Kekurangan: Membutuhkan ruang penyimpanan tambahan untuk tabel
hash.

Tabel Perbandingan Kompleksitas Waktu

Algoritma Kasus Terbaik Kasus Rata-rata Kasus Terburuk Catatan

Lambat,
Bubble
O(n)O(n)O(n) O(n2)O(n^2)O(n2) O(n2)O(n^2)O(n2) cocok untuk
Sort
dataset kecil.

12
Algoritma Kasus Terbaik Kasus Rata-rata Kasus Terburuk Catatan

Selection Implementasi
O(n2)O(n^2)O(n2) O(n2)O(n^2)O(n2) O(n2)O(n^2)O(n2)
Sort mudah.

Sangat cepat
Quick O(nlog⁡n)O(n \log O(nlog⁡n)O(n \log
O(n2)O(n^2)O(n2) untuk data
Sort n)O(nlogn) n)O(nlogn)
besar.

Stabil,
Merge O(nlog⁡n)O(n \log O(nlog⁡n)O(n \log O(nlog⁡n)O(n \log memerlukan
Sort n)O(nlogn) n)O(nlogn) n)O(nlogn) memori
tambahan.

Linear Sederhana
O(1)O(1)O(1) O(n)O(n)O(n) O(n)O(n)O(n)
Search tetapi lambat.

Binary O(log⁡n)O(\log O(log⁡n)O(\log O(log⁡n)O(\log Hanya untuk

Search n)O(logn) n)O(logn) n)O(logn) data terurut.

Dengan memahami algoritma dan kompleksitas waktu, pengembang dapat

memilih pendekatan yang paling sesuai untuk kebutuhan spesifik, baik dari segi
kecepatan maupun penggunaan sumber daya.

13
 BAB III

IMPLEMENTASI SORTING DALAM BAHASA C

3.1 BUBBLE SORT
#include <stdio.h>

// Fungsi untuk melakukan Bubble Sort

void bubbleSort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) { // Loop untuk setiap elemen

array

for (int j = 0; j < n - i - 1; j++) { // Loop untuk

membandingkan elemen

if (arr[j] > arr[j + 1]) { // Jika elemen lebih besar

dari elemen berikutnya

// Tukar elemen

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

14
 }

printf("\n");

int main() {

int arr[] = {64, 34, 25, 12, 22, 11, 90};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Array sebelum diurutkan: \n");

printArray(arr, n);

bubbleSort(arr, n);

printf("Array setelah diurutkan: \n");

printArray(arr, n);

return 0;

Penjelasan Program:
1. Fungsi bubbleSort:
 Menggunakan dua loop bersarang.
 Loop luar memastikan proses pengurutan diulang sebanyak ukuran
array dikurangi satu.
 Loop dalam membandingkan setiap pasangan elemen yang berdekatan
dan menukar posisinya jika tidak sesuai urutan.
2. Fungsi printArray:
 Mencetak elemen array dengan format yang rapi.
3. Bagian main:
 Mendefinisikan array yang akan diurutkan.
 Menampilkan array sebelum dan setelah proses pengurutan.

15
Output Program:
 Array sebelum diurutkan:
64 34 25 12 22 11 90
 Array setelah diurutkan:
11 12 22 25 34 64 90

3.2 SELECTION SORT

#include <stdio.h>

// Fungsi untuk melakukan Selection Sort

void selectionSort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {

int minIndex = i; // Anggap elemen ke-i adalah yang terkecil

for (int j = i + 1; j < n; j++) {

if (arr[j] < arr[minIndex]) { // Cari elemen terkecil di

sisa array

minIndex = j;

// Tukar elemen terkecil dengan elemen di posisi i

int temp = arr[minIndex];

arr[minIndex] = arr[i];

arr[i] = temp;

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

16
 printf("\n");

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Array sebelum diurutkan: \n");

printArray(arr, n);

selectionSort(arr, n);

printf("Array setelah diurutkan: \n");

printArray(arr, n);

return 0;

Penjelasan Program:
1. Fungsi selectionSort:
o Loop pertama memilih elemen awal sebagai yang terkecil.
o Loop kedua mencari elemen terkecil dari sisa array dan menyimpan
indeksnya di minIndex.
o Setelah selesai membandingkan, elemen terkecil ditukar dengan
elemen di posisi awal.
2. Fungsi printArray:
o Berfungsi untuk mencetak elemen array dalam format rapi.
3. Bagian main:
o Mendefinisikan array awal.
o Menampilkan array sebelum dan sesudah proses pengurutan.

17
Output Program:
Array sebelum diurutkan:
64 25 12 22 11

Array setelah diurutkan:

11 12 22 25 64

3.3 INSERTION SORT

#include <stdio.h>

// Fungsi untuk melakukan Insertion Sort

void insertionSort(int arr[], int n) {

for (int i = 1; i < n; i++) {

int key = arr[i]; // Ambil elemen yang akan disisipkan

int j = i - 1;

// Pindahkan elemen-elemen yang lebih besar dari key ke

posisi satu langkah lebih kanan

while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];

j = j - 1;

// Sisipkan key ke posisi yang tepat

arr[j + 1] = key;

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

18
 }

printf("\n");

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Array sebelum diurutkan: \n");

printArray(arr, n);

insertionSort(arr, n);

printf("Array setelah diurutkan: \n");

printArray(arr, n);

return 0;

Penjelasan Program:
1. Fungsi insertionSort:
o Mulai dengan elemen kedua (i = 1), ambil nilai elemen tersebut
sebagai key.
o Bandingkan elemen-elemen yang ada di sebelah kiri key dan geser
elemen-elemen yang lebih besar satu posisi ke kanan untuk memberi
ruang bagi key.
o Sisipkan key pada posisi yang tepat setelah geseran. Proses ini diulang
hingga seluruh array terurut.
2. Fungsi printArray:
o Digunakan untuk mencetak elemen array ke layar.
3. Bagian main:
o Mendefinisikan array dan mencetaknya sebelum dan sesudah proses
pengurutan.

Output Program:

19
Array sebelum diurutkan:
64 25 12 22 11

Array setelah diurutkan:

11 12 22 25 64

3.4 MERGE SORT

#include <stdio.h>

// Fungsi untuk menggabungkan dua subarray yang telah diurutkan

void merge(int arr[], int left, int mid, int right) {

int n1 = mid - left + 1; // Ukuran subarray kiri

int n2 = right - mid; // Ukuran subarray kanan

// Buat dua array sementara

int L[n1], R[n2];

// Salin data ke array sementara L[] dan R[]

for (int i = 0; i < n1; i++)

L[i] = arr[left + i];

for (int j = 0; j < n2; j++)

R[j] = arr[mid + 1 + j];

// Gabungkan dua subarray sementara ke dalam arr[]

int i = 0, j = 0, k = left;

while (i < n1 && j < n2) {

if (L[i] <= R[j]) {

arr[k] = L[i];

i++;

} else {

arr[k] = R[j];

20
 j++;

k++;

// Salin elemen yang tersisa dari L[], jika ada

while (i < n1) {

arr[k] = L[i];

i++;

k++;

// Salin elemen yang tersisa dari R[], jika ada

while (j < n2) {

arr[k] = R[j];

j++;

k++;

// Fungsi untuk melakukan pembagian array dan memanggil merge

void mergeSort(int arr[], int left, int right) {

if (left < right) {

int mid = left + (right - left) / 2; // Temukan titik

tengah

mergeSort(arr, left, mid); // Urutkan bagian kiri

mergeSort(arr, mid + 1, right); // Urutkan bagian kanan

merge(arr, left, mid, right); // Gabungkan hasilnya

21
// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Array sebelum diurutkan: \n");

printArray(arr, n);

mergeSort(arr, 0, n - 1);

printf("Array setelah diurutkan: \n");

printArray(arr, n);

return 0;

Penjelasan Program:
1. Fungsi merge:
o Fungsi ini menggabungkan dua subarray yang sudah terurut menjadi
satu array yang terurut.
o Array kiri dan kanan dibandingkan elemen demi elemen dan disalin
kembali ke array utama.

22
 2. Fungsi mergeSort:
o Fungsi ini membagi array menjadi dua bagian secara rekursif hingga
setiap subarray hanya memiliki satu elemen. Kemudian, fungsi merge
digunakan untuk menggabungkan dua subarray yang sudah terurut.
o Fungsi rekursif ini membagi array hingga bagian terkecil (elemen
tunggal) sebelum melakukan penggabungan dan pengurutan.
3. Fungsi printArray:
o Digunakan untuk mencetak elemen array ke layar.
4. Bagian main:
o Mendefinisikan array yang akan diurutkan dan mencetaknya sebelum
dan sesudah pengurutan dengan Merge Sort.

Output Program:

Array sebelum diurutkan:

64 25 12 22 11

Array setelah diurutkan:

11 12 22 25 64

3.5 QUICK SORT

#include <stdio.h>

// Fungsi untuk membagi array dan menemukan posisi pivot

int partition(int arr[], int low, int high) {

int pivot = arr[high]; // Ambil elemen terakhir sebagai pivot

int i = (low - 1); // Indeks elemen terkecil

// Membandingkan elemen dengan pivot dan menukar jika diperlukan

for (int j = low; j <= high - 1; j++) {

if (arr[j] <= pivot) { // Jika elemen lebih kecil dari

pivot

i++; // Menambah indeks elemen terkecil

23
 // Tukar arr[i] dan arr[j]

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

// Tukar pivot dengan elemen setelah elemen terkecil

int temp = arr[i + 1];

arr[i + 1] = arr[high];

arr[high] = temp;

return (i + 1); // Kembalikan indeks pivot

// Fungsi untuk melakukan quick sort secara rekursif

void quickSort(int arr[], int low, int high) {

if (low < high) {

// Temukan indeks pivot yang benar

int pi = partition(arr, low, high);

// Urutkan elemen di kiri dan kanan pivot

quickSort(arr, low, pi - 1);

quickSort(arr, pi + 1, high);

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

24
 for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Array sebelum diurutkan: \n");

printArray(arr, n);

quickSort(arr, 0, n - 1);

printf("Array setelah diurutkan: \n");

printArray(arr, n);

return 0;

Penjelasan Program:
1. Fungsi partition:
o Fungsi ini memilih elemen terakhir (pivot) dan memindahkan elemen-
elemen yang lebih kecil dari pivot ke kiri dan yang lebih besar ke
kanan. Setelah itu, pivot ditempatkan pada posisi yang benar.
o Fungsi ini mengembalikan indeks pivot yang tepat.
2. Fungsi quickSort:
o Fungsi rekursif ini membagi array menjadi dua bagian berdasarkan
posisi pivot yang dikembalikan oleh partition.

25
 o Kemudian, fungsi ini memanggil dirinya sendiri untuk mengurutkan
dua bagian tersebut secara terpisah.
3. Fungsi printArray:
o Digunakan untuk mencetak elemen array ke layar.
4. Bagian main:
o Mendefinisikan array yang akan diurutkan dan mencetaknya sebelum
dan sesudah pengurutan dengan Quick Sort.

Output Program:

Array sebelum diurutkan:

64 25 12 22 11

Array setelah diurutkan:

11 12 22 25 64

3.6 PERBANDINGAN DAN EFISIENSI SORTING

Di bawah ini adalah perbandingan antara algoritma sorting yang telah dibahas,
yaitu Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, dan Quick Sort.
Kita akan melihat kompleksitas waktu dan ruang, serta kelebihan dan kekurangan
masing-masing algoritma.

1. Bubble Sort
 Kompleksitas Waktu:
o Kasus Terburuk (Worst case): O(n2)O(n^2)O(n2)
o Kasus Rata-rata (Average case): O(n2)O(n^2)O(n2)
o Kasus Terbaik (Best case): O(n)O(n)O(n) (Jika array sudah terurut)
 Kompleksitas Ruang:
o O(1)O(1)O(1) (in-place sorting, hanya membutuhkan sedikit ruang
tambahan)
 Kelebihan:
o Mudah diimplementasikan.

26
 o Menyortir array yang sudah terurut dengan cepat.

 Kekurangan:
o Tidak efisien untuk dataset besar.
o Kompleksitas waktu O(n2)O(n^2)O(n2) di kasus rata-rata dan
terburuk membuatnya lambat pada array besar.

2. Selection Sort
 Kompleksitas Waktu:
o Kasus Terburuk (Worst case): O(n2)O(n^2)O(n2)
o Kasus Rata-rata (Average case): O(n2)O(n^2)O(n2)
o Kasus Terbaik (Best case): O(n2)O(n^2)O(n2) (Karena selalu
melakukan perbandingan)
 Kompleksitas Ruang:
o O(1)O(1)O(1) (in-place sorting, hanya membutuhkan sedikit ruang
tambahan)
 Kelebihan:
o Mudah diimplementasikan.
o Tidak memerlukan ruang tambahan selain untuk variabel sementara.
o Lebih sedikit pertukaran elemen dibandingkan Bubble Sort.
 Kekurangan:
o Tidak efisien untuk dataset besar karena kompleksitas waktu
O(n2)O(n^2)O(n2) di semua kasus.
o Tidak stabil (dua elemen dengan nilai yang sama mungkin bertukar
tempat).

3. Insertion Sort

27
  Kompleksitas Waktu:
o Kasus Terburuk (Worst case): O(n2)O(n^2)O(n2)
o Kasus Rata-rata (Average case): O(n2)O(n^2)O(n2)
o Kasus Terbaik (Best case): O(n)O(n)O(n) (Jika array sudah terurut)

 Kompleksitas Ruang:
o O(1)O(1)O(1) (in-place sorting, hanya membutuhkan sedikit ruang
tambahan)
 Kelebihan:
o Sangat efisien pada array yang hampir terurut.
o Stabil (elemen dengan nilai yang sama tetap dalam urutan yang sama).
o Menggunakan sedikit ruang tambahan.
 Kekurangan:
o Kompleksitas waktu O(n2)O(n^2)O(n2) pada kasus rata-rata dan
terburuk, membuatnya tidak efisien pada dataset besar.
4. Merge Sort
 Kompleksitas Waktu:
o Kasus Terburuk (Worst case): O(nlog⁡n)O(n \log n)O(nlogn)
o Kasus Rata-rata (Average case): O(nlog⁡n)O(n \log n)O(nlogn)
o Kasus Terbaik (Best case): O(nlog⁡n)O(n \log n)O(nlogn)
 Kompleksitas Ruang:
o O(n)O(n)O(n) (memerlukan ruang tambahan untuk array sementara)
 Kelebihan:
o Stabil (mempertahankan urutan relatif elemen yang sama).
o Efisien untuk dataset besar dengan kompleksitas waktu yang konsisten
O(nlog⁡n)O(n \log n)O(nlogn).

28
 o Memiliki performa yang baik pada dataset besar atau ketika
menggunakan data yang tidak dapat dimuat seluruhnya di memori.
 Kekurangan:
o Membutuhkan ruang tambahan O(n)O(n)O(n), yang membuatnya
kurang efisien dalam penggunaan memori.
o Tidak secepat Quick Sort untuk dataset kecil.

5. Quick Sort
 Kompleksitas Waktu:
o Kasus Terburuk (Worst case): O(n2)O(n^2)O(n2) (Jika pivot yang
dipilih buruk)
o Kasus Rata-rata (Average case): O(nlog⁡n)O(n \log n)O(nlogn)
o Kasus Terbaik (Best case): O(nlog⁡n)O(n \log n)O(nlogn)
 Kompleksitas Ruang:
o O(log⁡n)O(\log n)O(logn) (in-place sorting, hanya membutuhkan ruang
tambahan untuk rekursi)
 Kelebihan:
o Sangat efisien pada dataset besar dengan kompleksitas waktu
O(nlog⁡n)O(n \log n)O(nlogn) di kasus rata-rata.
o In-place sorting, hanya memerlukan ruang tambahan untuk rekursi.
o Salah satu algoritma sorting tercepat dalam praktik.
 Kekurangan:
o Kompleksitas waktu O(n2)O(n^2)O(n2) di kasus terburuk jika pivot
yang dipilih tidak baik (misalnya, jika array sudah terurut).
o Tidak stabil (elemen dengan nilai yang sama dapat berubah posisi
relatifnya).
Kesimpulan:

29
  Bubble Sort, Selection Sort, dan Insertion Sort lebih cocok digunakan
untuk dataset kecil atau ketika kesederhanaan algoritma menjadi prioritas.
 Merge Sort dan Quick Sort lebih efisien untuk dataset besar, dengan Merge
Sort yang stabil dan Quick Sort yang cepat dalam praktik meskipun dengan
kemungkinan kasus terburuk.

BAB IV

IMPLEMENTASI SEARCHING DALAM BAHASA C

4.1 LINEAR SEARCH
Linear Search adalah salah satu algoritma pencarian yang paling sederhana.
Algoritma ini mencari elemen dengan cara memeriksa setiap elemen dalam array atau
daftar satu per satu, mulai dari elemen pertama hingga elemen terakhir, sampai
elemen yang dicari ditemukan atau seluruh elemen dalam array telah diperiksa.
Algoritma Linear Search
1. Mulai dari elemen pertama dalam array.
2. Bandingkan elemen yang sedang diperiksa dengan nilai yang dicari.
3. Jika elemen yang dicari ditemukan, kembalikan posisi elemen tersebut.
4. Jika elemen yang dicari tidak ditemukan setelah memeriksa semua elemen,
kembalikan nilai yang menunjukkan bahwa elemen tidak ada (biasanya -1
atau null).
5. Proses ini berlanjut hingga elemen ditemukan atau seluruh array selesai
diperiksa.
#include <stdio.h>

// Fungsi untuk melakukan pencarian linear

int linearSearch(int arr[], int n, int key) {

for (int i = 0; i < n; i++) {

if (arr[i] == key) {

30
 return i; // Kembalikan indeks elemen yang ditemukan

return -1; // Elemen tidak ditemukan

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

int key = 22; // Elemen yang ingin dicari

printf("Array: \n");

printArray(arr, n);

int result = linearSearch(arr, n, key);

if (result != -1) {

printf("Elemen %d ditemukan pada indeks %d\n", key, result);

} else {

printf("Elemen %d tidak ditemukan\n", key);

31
 return 0;

Penjelasan Program:
1. Fungsi linearSearch:
o Fungsi ini menerima array arr[], panjang array n, dan nilai yang ingin
dicari (key).
o Fungsi ini kemudian memeriksa setiap elemen dalam array untuk
mencari elemen yang cocok dengan key.
o Jika ditemukan, fungsi akan mengembalikan indeks elemen tersebut.
Jika tidak ditemukan, fungsi mengembalikan -1.
2. Fungsi printArray:
o Digunakan untuk mencetak elemen-elemen array ke layar.
3. Bagian main:
o Mendefinisikan array yang akan dicari dan nilai key yang akan dicari
dalam array.
o Memanggil fungsi linearSearch untuk mencari elemen dan mencetak
hasilnya.

Output Program:
Array:
64 25 12 22 11

Elemen 22 ditemukan pada indeks 3

4.2 BINARY SEARCH

Binary Search adalah algoritma pencarian yang efisien untuk mencari elemen
dalam array yang sudah terurut. Algoritma ini bekerja dengan membagi array yang
terurut menjadi dua bagian secara berulang dan memilih bagian yang kemungkinan
besar mengandung elemen yang dicari. Proses ini diulang hingga elemen ditemukan
atau hingga bagian array yang tersisa tidak mengandung elemen tersebut.
Cara Kerja Binary Search:

32
 1. Tentukan indeks tengah dari array.
2. Bandingkan elemen tengah dengan elemen yang dicari.
o Jika elemen tengah sama dengan elemen yang dicari, pencarian selesai
dan kembalikan indeksnya.
o Jika elemen tengah lebih besar dari elemen yang dicari, periksa bagian
kiri dari array (kurangi indeks bagian kanan).
o Jika elemen tengah lebih kecil dari elemen yang dicari, periksa bagian
kanan dari array (tingkatkan indeks bagian kiri).
3. Ulangi langkah ini dengan membagi array menjadi dua bagian hingga elemen
ditemukan atau array tidak memiliki elemen yang tersisa.
Implementasi Binary Search dalam C
#include <stdio.h>

// Fungsi untuk melakukan pencarian binary search

int binarySearch(int arr[], int low, int high, int key) {

while (low <= high) {

int mid = low + (high - low) / 2; // Menghitung indeks

tengah

// Jika elemen yang dicari ditemukan

if (arr[mid] == key) {

return mid;

// Jika elemen yang dicari lebih kecil dari elemen tengah

if (arr[mid] > key) {

high = mid - 1;

// Jika elemen yang dicari lebih besar dari elemen tengah

else {

33
 low = mid + 1;

return -1; // Elemen tidak ditemukan

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {11, 12, 22, 25, 64}; // Array yang sudah terurut

int n = sizeof(arr) / sizeof(arr[0]);

int key = 22; // Elemen yang ingin dicari

printf("Array: \n");

printArray(arr, n);

int result = binarySearch(arr, 0, n - 1, key);

if (result != -1) {

printf("Elemen %d ditemukan pada indeks %d\n", key, result);

} else {

printf("Elemen %d tidak ditemukan\n", key);

34
 return 0;

Penjelasan Program:
1. Fungsi binarySearch:
o Fungsi ini menerima array arr[], indeks kiri (low), indeks kanan
(high), dan elemen yang ingin dicari (key).
o Algoritma ini membagi array menjadi dua bagian pada setiap iterasi
dengan menghitung indeks tengah (mid), dan membandingkan nilai di
tengah dengan nilai yang dicari.
o Jika ditemukan, fungsi mengembalikan indeks elemen tersebut. Jika
tidak, pencarian dilanjutkan di bagian kiri atau kanan array sesuai
kondisi.
2. Fungsi printArray:
o Fungsi ini digunakan untuk mencetak elemen-elemen array ke layar.
3. Bagian main:
o Array yang sudah terurut didefinisikan, dan elemen yang dicari (key)
diberikan nilai.
o Fungsi binarySearch dipanggil untuk mencari elemen dan mencetak
hasilnya.

Output Program:

Array:
11 12 22 25 64

Elemen 22 ditemukan pada indeks 2

35
4.3 IMPLEMENTASI PADA DATA ARRAY
Untuk lebih jelasnya, berikut ini adalah implementasi Binary Search pada array
yang berisi data angka. Program ini akan mencari elemen tertentu dalam array yang
sudah terurut dan menampilkan hasil pencarian.
Contoh Program Binary Search pada Data Array
Misalkan kita ingin mencari angka tertentu di dalam array berikut: {11, 12, 22, 25,
64, 70, 88, 99}. Kita akan mencari angka 22 dalam array ini menggunakan Binary
Search.
#include <stdio.h>

// Fungsi untuk melakukan pencarian binary search

int binarySearch(int arr[], int low, int high, int key) {

while (low <= high) {

int mid = low + (high - low) / 2; // Menghitung indeks

tengah

// Jika elemen yang dicari ditemukan

if (arr[mid] == key) {

return mid;

// Jika elemen yang dicari lebih kecil dari elemen tengah

if (arr[mid] > key) {

high = mid - 1;

// Jika elemen yang dicari lebih besar dari elemen tengah

else {

low = mid + 1;

36
 return -1; // Elemen tidak ditemukan

// Fungsi untuk mencetak array

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

printf("\n");

int main() {

// Data array yang sudah terurut

int arr[] = {11, 12, 22, 25, 64, 70, 88, 99};

int n = sizeof(arr) / sizeof(arr[0]);

int key = 22; // Elemen yang ingin dicari

// Mencetak array

printf("Array: \n");

printArray(arr, n);

// Melakukan pencarian dengan binary search

int result = binarySearch(arr, 0, n - 1, key);

// Menampilkan hasil pencarian

if (result != -1) {

printf("Elemen %d ditemukan pada indeks %d\n", key, result);

} else {

printf("Elemen %d tidak ditemukan\n", key);

37
 }

return 0;

Penjelasan Program:
1. Array yang Terurut:
2. Dalam program ini, kita menggunakan array yang sudah terurut: {11, 12, 22,
25, 64, 70, 88, 99}.
3. Fungsi binarySearch:
o Menerima array arr[], indeks kiri (low), indeks kanan (high), dan
elemen yang ingin dicari (key).
o Fungsi ini bekerja dengan cara membagi array menjadi dua bagian
pada setiap langkah pencarian. Elemen tengah dibandingkan dengan
elemen yang dicari, dan berdasarkan perbandingan tersebut, bagian
kiri atau kanan array akan dipilih untuk pencarian berikutnya.
4. Fungsi printArray:
o Fungsi ini digunakan untuk mencetak seluruh elemen array.
5. Bagian main:
o Array didefinisikan, dan elemen yang dicari (key = 22) ditentukan.
o Fungsi binarySearch dipanggil untuk mencari elemen dalam array dan
hasilnya dicetak ke layar.
Output Program:
Array:

11 12 22 25 64 70 88 99

Elemen 22 ditemukan pada indeks 2

38
4.4 STUDI KASUS DAN ANALISIS EFISIENSI
Dalam dunia pemrograman dan ilmu komputer, Binary Search adalah salah satu
algoritma pencarian yang paling efisien untuk mencari elemen dalam array yang
sudah terurut. Untuk memahami efisiensi Binary Search, kita akan melihat studi
kasus dan analisisnya dalam konteks waktu eksekusi dan penggunaan sumber daya.

Studi Kasus: Pencarian Data dalam Array Terurut

Misalkan kita memiliki aplikasi yang mengelola data pengguna, dan kita ingin
mencari ID pengguna dalam sebuah array yang terurut. Data pengguna memiliki ID
dari 1 hingga 1 juta, dan kita ingin mencari ID tertentu, misalnya ID = 500,000.
Data:
 Array terurut yang berisi ID pengguna dari 1 hingga 1 juta: {1, 2, 3, ...,
1000000}.
 Kita ingin mencari ID = 500,000.

Langkah-langkah dengan Binary Search:

1. Inisialisasi:
o Array berisi 1 juta elemen yang terurut.
o low = 0 (indeks pertama), high = 999999 (indeks terakhir).
2. Iterasi Pertama:
o Hitung mid = (low + high) / 2 = (0 + 999999) / 2 = 499999.
o Elemen di indeks 499999 adalah 500,000, yang merupakan ID yang
kita cari.
3. Hasil:
o Setelah hanya satu iterasi, Binary Search berhasil menemukan ID yang
dicari di indeks 499999.

39
Perbandingan dengan Linear Search:
Jika kita menggunakan Linear Search untuk mencari ID = 500,000 dalam
array yang berisi 1 juta elemen, kita perlu memeriksa setiap elemen satu per satu,
mulai dari indeks 0 hingga 499999.
 Waktu untuk Linear Search: O(n), dimana n adalah jumlah elemen dalam
array. Dalam kasus ini, pencarian akan membutuhkan hingga 500,000
perbandingan.
 Waktu untuk Binary Search: O(log n), dimana n adalah jumlah elemen
dalam array. Dalam kasus ini, hanya dibutuhkan sekitar 20 perbandingan
(log₂(1,000,000) ≈ 20).
Analisis Efisiensi Binary Search
1. Kompleksitas Waktu (Time Complexity):
 Waktu Terburuk (Worst Case):
Binary Search bekerja dengan membagi array menjadi dua bagian pada setiap
langkah. Oleh karena itu, jumlah langkah pencarian yang diperlukan untuk
menemukan elemen atau menentukan bahwa elemen tidak ada adalah sekitar
log⁡2n\log_2 nlog2n, di mana n adalah ukuran array.
Jadi, kompleksitas waktu Binary Search adalah O(log⁡n)O(\log n)O(logn).
Misalnya, untuk array berukuran 1 juta elemen:
o Binary Search akan membutuhkan sekitar 20 langkah (log₂ 1,000,000
≈ 20).
2. Kompleksitas Waktu Rata-rata (Average Case):
 Karena Binary Search membagi array menjadi dua bagian setiap kali, waktu
yang dibutuhkan untuk pencarian tidak tergantung pada posisi elemen yang
dicari, sehingga kompleksitas waktu rata-rata juga adalah O(log⁡n)O(\log
n)O(logn).
3. Kompleksitas Ruang (Space Complexity):
 Kompleksitas Ruang:

40
 Binary Search hanya memerlukan beberapa variabel tambahan untuk melacak
indeks kiri (low), kanan (high), dan tengah (mid), sehingga kompleksitas
ruangnya adalah O(1) (konstan).
4. Efisiensi pada Data Besar:
 Jika kita memiliki data yang sangat besar (misalnya miliaran elemen), Binary
Search masih akan bekerja dengan sangat cepat. Sebagai contoh:
o Untuk array dengan 1 juta elemen, Binary Search hanya membutuhkan
sekitar 20 langkah.
o Untuk array dengan 1 miliar elemen, Binary Search hanya
membutuhkan sekitar 30 langkah.
Di sisi lain, Linear Search akan memerlukan waktu yang sangat lama pada data
besar karena kompleksitasnya adalah O(n)O(n)O(n).

Contoh Penggunaan Binary Search pada Data Besar:

Misalkan Anda memiliki dataset berukuran 1 miliar elemen yang terurut, dan Anda
ingin mencari apakah elemen 500,000,000 ada dalam array tersebut.
 Dengan Binary Search, proses pencarian akan memerlukan sekitar 30
perbandingan, terlepas dari ukuran array.
 Dengan Linear Search, Anda harus memeriksa hingga 500 juta elemen, yang
jelas jauh lebih lambat.

Kesimpulan:
 Binary Search sangat efisien pada array yang terurut, dengan kompleksitas
waktu O(log⁡n)O(\log n)O(logn), yang membuatnya ideal untuk pencarian
cepat dalam dataset besar.
 Linear Search, meskipun mudah diimplementasikan, tidak efisien untuk
dataset besar karena kompleksitasnya adalah O(n)O(n)O(n).
 Pada aplikasi dunia nyata yang mengelola data besar (seperti pencarian ID
pengguna atau data produk), Binary Search memberikan keunggulan yang
signifikan dalam hal kecepatan pencarian dibandingkan dengan algoritma
pencarian lainnya.

41
 Dengan demikian, jika data Anda sudah terurut, menggunakan Binary Search
adalah pilihan yang lebih efisien dibandingkan dengan pencarian linier, terutama pada
dataset besar.

BAB VI

KESIMPULAN DAN SARAN

6.1 KESIMPULAN
Dari pembahasan yang telah dilakukan, dapat disimpulkan bahwa Binary Search
adalah algoritma pencarian yang sangat efisien ketika digunakan pada array yang
sudah terurut. Keunggulan utamanya terletak pada kompleksitas waktunya yang
rendah, yaitu O(log⁡n)O(\log n)O(logn), yang membuatnya sangat cepat bahkan untuk
dataset yang sangat besar.
Beberapa poin penting yang dapat diambil dari pembahasan ini adalah:
1. Efisiensi Waktu:
o Binary Search memiliki kompleksitas waktu O(log⁡n)O(\log n)O(logn),
yang sangat efisien dibandingkan dengan algoritma pencarian lain
seperti Linear Search yang memiliki kompleksitas O(n)O(n)O(n).
o Pada dataset besar, Binary Search dapat menemukan elemen dengan
hanya beberapa perbandingan, membuatnya jauh lebih cepat.
2. Persyaratan Data Terurut:
o Binary Search hanya dapat digunakan pada array yang sudah terurut.
Jika data tidak terurut, diperlukan langkah pengurutan terlebih dahulu
yang memakan waktu, seperti menggunakan algoritma Merge Sort
atau Quick Sort.
3. Penggunaan pada Data Besar:
o Pada data yang besar, misalnya dengan miliaran elemen, Binary
Search masih mampu memberikan hasil pencarian dalam waktu yang

42
 sangat cepat. Ini berbeda dengan Linear Search yang akan memakan
waktu lebih lama seiring dengan bertambahnya jumlah elemen.
4. Kompleksitas Ruang:
o Binary Search sangat hemat dalam penggunaan ruang, dengan
kompleksitas ruang O(1)O(1)O(1), karena hanya membutuhkan
beberapa variabel untuk menyimpan indeks yang diperlukan dalam
pencarian.

5. Pentingnya Pengurutan Data:

o Salah satu syarat utama untuk menggunakan Binary Search adalah
bahwa data harus terurut. Jika data tidak terurut, perlu dilakukan
pengurutan terlebih dahulu, yang akan menambah waktu eksekusi
algoritma.
Secara keseluruhan, Binary Search adalah solusi yang sangat efisien dan efektif untuk
masalah pencarian dalam array yang terurut. Dengan kemampuannya untuk
mengurangi jumlah perbandingan secara signifikan, Binary Search merupakan pilihan
utama dalam aplikasi yang membutuhkan pencarian cepat, terutama ketika bekerja
dengan dataset besar.

6.2 SARAN
Berdasarkan hasil studi dan analisis yang telah dilakukan mengenai Binary
Search, berikut adalah beberapa saran untuk pengembangan dan implementasi lebih
lanjut:
1. Penggunaan Binary Search pada Data Terurut:
o Pastikan data yang digunakan dalam pencarian sudah terurut. Jika data
tidak terurut, lebih baik untuk mengurutkannya terlebih dahulu
menggunakan algoritma pengurutan yang efisien, seperti Merge Sort
atau Quick Sort, sebelum melakukan Binary Search.
o Jika data sering diperbarui (seperti data dinamis), pertimbangkan
untuk menggunakan struktur data seperti Self-Balancing Binary
Search Trees (seperti AVL Trees atau Red-Black Trees) untuk
menjaga data tetap terurut dan memungkinkan pencarian yang cepat
tanpa harus mengurutkan ulang seluruh array.

43
 2. Memperhatikan Efisiensi Pengurutan:
o Jika dataset Anda terus berkembang dan pengurutan menjadi
bottleneck, pertimbangkan untuk menggunakan algoritma pengurutan
yang lebih efisien dalam konteks waktu dan ruang, seperti Quick Sort
(untuk waktu terbaik) atau Merge Sort (untuk stabilitas dan
kompleksitas waktu yang konsisten).
3. Penggunaan Binary Search pada Data yang Sangat Besar:
o Pada dataset yang sangat besar, misalnya yang disimpan di database
atau dalam sistem distribusi, pertimbangkan untuk memanfaatkan
algoritma pencarian terdistribusi yang serupa dengan Binary Search,
atau gunakan teknik pencarian berbasis indeks untuk meningkatkan
efisiensi pencarian di luar memori lokal.
4. Implementasi dalam Aplikasi Dunia Nyata:
o Dalam aplikasi yang membutuhkan pencarian cepat, seperti aplikasi e-
commerce atau basis data, menggunakan Binary Search untuk
pencarian produk atau data yang terurut dapat sangat meningkatkan
kinerja.
o Selain itu, pertimbangkan untuk mengimplementasikan Caching pada
sistem pencarian untuk data yang sering dicari, guna mengurangi
waktu akses dan meningkatkan pengalaman pengguna.
5. Pemahaman tentang Kompleksitas:
o Penting untuk memahami batasan dan kompleksitas waktu serta ruang
dalam menggunakan Binary Search. Sementara Binary Search
sangat efisien, pengurutan data yang membutuhkan waktu
O(nlog⁡n)O(n \log n)O(nlogn) pada awalnya bisa menjadi hambatan
jika data sering berubah.
o Selalu pertimbangkan karakteristik data dan kebutuhan aplikasi saat
memilih algoritma pencarian. Untuk data yang sering berubah,
algoritma pencarian lain yang lebih fleksibel bisa jadi lebih tepat,
meskipun sedikit lebih lambat, seperti Linear Search atau pencarian
menggunakan hash table.
Dengan mengimplementasikan saran-saran ini, kita dapat lebih memaksimalkan
keefisienan Binary Search dalam berbagai situasi dan kondisi data, serta
meningkatkan kinerja dan responsivitas aplikasi yang mengandalkan pencarian data.

44
6.3 DAFTAR PUSTAKA
 Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms
(3rd ed.). The MIT Press.

 Knuth, D. E. (1998). The Art of Computer Programming, Volume 3: Sorting and Searching
(2nd ed.). Addison-Wesley.

 Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley.

 Weiss, M. A. (2013). Data Structures and Algorithm Analysis in C (4th ed.). Pearson
Education.

 Baase, S., & Van Gutt, A. (2016). Computer Algorithms: Introduction to Design and
Analysis (3rd ed.). Pearson.

 Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer.

 GeeksforGeeks. (2020). Binary Search Algorithm. Diakses dari:

https://www.geeksforgeeks.org/binary-search/

 Wikipedia Contributors. (2024). Binary Search. Diakses dari:

45