LAPORAN UAS COMPUTATIONAL THINKING KELOMPOK 7

Disusun Untuk Memenuhi Mata Kuliah

Computational Thinking

Disusun Oleh :
Lisa Febriyanti 2210512149
M. Varian Warrick 2210512153
Aura Rachmawaty 2210512155
Alvian Nurhaliza Putri 2210512164
Davy Putra Ananda 2210512166

Dosen Pengampu :
Sarika, S.Kom., M.Kom.

PROGRAM STUDI SISTEM INFORMASI

FAKULTAS ILMU KOMPUTER
UNIVERSITAS PEMBANGUNAN NASIONAL VETERAN JAKARTA
Jalan RS. Fatmawati Raya, Pd. Labu, Kec. Cilandak, Kota Depok, Jawa
Barat 12450
2023
 DAFTAR ISI

DAFTAR ISI.............................................................................................................................. i
DAFTAR GAMBAR................................................................................................................ ii
BAB I PENDAHULUAN......................................................................................................... 1
1.1 Latar Belakang............................................................................................................... 1
1.2 Rumusan Masalah.......................................................................................................... 2
1.3 Tujuan.............................................................................................................................2
BAB II PEMBAHASAN.......................................................................................................... 3
2.1 Deskripsi Project............................................................................................................ 3
2.2 Implementasi Struktur Data........................................................................................... 3
2.2.1 Insertion Sort......................................................................................................... 3
2.2.2 Selection Sort........................................................................................................ 5
2.2.3 Shell Sort............................................................................................................... 6
2.2.4 Merge Sort.............................................................................................................7
2.2.5 Heap Sort...............................................................................................................8
2.2.6 Bubble Sort............................................................................................................8
2.2.7 Graf........................................................................................................................9
2.3 Implementasi Program................................................................................................. 10
2.3.1 Insertion Sort....................................................................................................... 10
2.3.2 Selection Sort...................................................................................................... 12
2.3.3 Shell Sort............................................................................................................. 14
2.3.4 Merge Sort...........................................................................................................16
2.3.5 Heap Sort.............................................................................................................18
2.3.6 Bubble Sort..........................................................................................................21
2.3.7 Graf......................................................................................................................22
BAB III PENUTUP................................................................................................................ 26
3.1 Kesimpulan...................................................................................................................26
3.2 Saran.............................................................................................................................26
DAFTAR PUSTAKA..............................................................................................................28
LAMPIRAN............................................................................................................................ 29

i
 DAFTAR GAMBAR

Gambar 2.2.1 Ilustrasi Insertion Sort......................................................................................... 4

Gambar 2.2.2 Visualisasi Selection Sort.................................................................................... 6
Gambar 2.2.4 Visualisasi Merge Sort.........................................................................................8

ii
 BAB I
PENDAHULUAN

1.1 Latar Belakang

Pada era digital yang terus berkembang, pengolahan data telah menjadi bagian
tak terpisahkan dari kehidupan sehari-hari. Konsep computational thinking, sebuah
kerangka berpikir yang sistematis dalam menyelesaikan masalah dengan
menggunakan algoritma dan struktur data, menjadi pondasi utama dalam mengatasi
kompleksitas pengolahan data. Struktur data, algoritma pengurutan, dan representasi
data dalam bentuk graf memainkan peran sentral dalam pengembangan aplikasi dan
sistem informasi.
Komputasi modern membutuhkan keefisienan dan keakuratan dalam
manipulasi data. Struktur data dan algoritma pengurutan adalah pilar utama yang
mempengaruhi kinerja aplikasi dalam pengelolaan, pencarian, penyimpanan, dan
pemrosesan data secara efisien. Sementara itu, representasi data dalam bentuk graf
menjadi kunci untuk memodelkan hubungan kompleks antara entitas dalam berbagai
konteks, memungkinkan analisis yang mendalam terhadap interaksi antar elemen.
Penggunaan computational thinking membawa pemikiran sistematis dalam
menyelesaikan masalah yang melibatkan data. Penerapan konsep ini tidak hanya
memungkinkan pengelolaan data yang lebih baik, tetapi juga memungkinkan
pengembang untuk membuat keputusan yang lebih terinformasi, menemukan pola
yang tersembunyi, dan mengoptimalkan kinerja aplikasi secara keseluruhan.
Laporan ini akan mengulas tentang pentingnya struktur data, algoritma
pengurutan, dan representasi data dalam bentuk graf sebagai fondasi utama dalam
pengembangan aplikasi dan sistem informasi. Dalam konteks ini, penekanan akan
diberikan pada penerapan computational thinking dalam memahami, merancang, dan
mengimplementasikan solusi-solusi yang efektif dalam pengolahan data.

1
1.2 Rumusan Masalah
1. Bagaimana konsep computational thinking dapat diterapkan secara efektif dalam
mengatasi kompleksitas pengolahan data pada era digital yang terus berkembang?
2. Apa peran utama struktur data dan algoritma pengurutan dalam meningkatkan
keefisienan dan keakuratan manipulasi data dalam konteks komputasi modern?
3. Mengapa representasi data dalam bentuk graf menjadi kunci penting dalam
memodelkan hubungan kompleks antara entitas dalam berbagai konteks, dan
bagaimana hal ini dapat mendukung analisis yang mendalam terhadap interaksi
antar elemen?
1.3 Tujuan
1. Menilai sejauh mana konsep computational thinking dapat diterapkan dalam
pengembangan solusi-solusi efektif untuk mengelola, mencari, menyimpan, dan
memproses data dengan kompleksitas yang tinggi.
2. Menganalisis dampak dan peran struktur data serta algoritma pengurutan dalam
meningkatkan kinerja aplikasi pada pengelolaan data, dengan fokus pada efisiensi
dan akurasi manipulasi data.
3. Mengevaluasi keefektifan representasi data dalam bentuk graf sebagai metode
untuk memodelkan hubungan antar entitas, dan bagaimana hal ini dapat
mendukung analisis mendalam terhadap interaksi antar elemen dalam berbagai
konteks pengolahan data.

2
 BAB II
PEMBAHASAN

2.1 Deskripsi Project

Project ini bertujuan untuk mengimplementasikan beberapa algoritma

pengurutan, termasuk Insertion Sort, Selection Sort, Shell Sort, Merge Sort, Heap
Sort, dan Bubble Sort. Selain itu, menambahkan fitur representasi graf untuk
memodelkan hubungan antar entitas. Implementasi algoritma pengurutan memberikan
pemahaman mendalam tentang berbagai pendekatan yang dapat diambil untuk
mengurutkan data dengan efisien, sementara representasi graf akan memperkaya
kemampuan project untuk memodelkan dan menganalisis interaksi antar entitas.

Project ini akan menyediakan fungsionalitas untuk mengurutkan berbagai jenis

data menggunakan berbagai algoritma yang dipilih. Setiap algoritma akan
diimplementasikan secara terpisah untuk memahami perbedaan kinerja dan
kompleksitas masing-masing. Seiring itu, fitur representasi graf akan memungkinkan
pengguna untuk memahami dan memvisualisasikan hubungan antar elemen dalam
konteks graf.

Manfaatnya mencakup peningkatan pemahaman terhadap konsep-konsep

dasar dalam ilmu komputer dan pemrograman, pengembangan keterampilan
implementasi algoritma, dan pemahaman tentang penggunaan struktur data graf untuk
memodelkan situasi dunia nyata. Sebagai tambahan, proyek ini dapat memberikan
wawasan tentang perbandingan kinerja antar algoritma pengurutan dan aplikasi
representasi graf dalam analisis data dan hubungan antar elemen.

2.2 Implementasi Struktur Data

2.2.1 Insertion Sort
Algoritma insertion sort, adalah metode pengurutan dengan cara
menyisipkan elemen data pada posisi yang tepat. Pencarian posisi yang
tepat dilakukan dengan melakukan pencarian berurutan didalam barisan
elemen, selama pencarian posisi yang tepat dilakukan pergeseran elemen
[Sitorus and Sembiring, 2012]

Pengurutan insertion sort sangat mirip dengan konsep permainan

kartu, bahwa setiap kartu disisipkan secara berurutan dari kiri ke kanan sesuai
dengan besar nilai kartu tersebut, dengan syarat apabila sebuah kartu
disisipkan pada posisi tertentu kartu yang lain akan bergeser maju atau
mundur sesuai dengan besaran nilai yang dimiliki [Ramadhani, 2015]

3
Proses Algoritma Insertion Sort:
1. Inisialisasi: Mulai dari indeks ke-1 dalam array. Bagian ini dianggap
sebagai “bagian yang sudah diurutkan”.

2. Pilih Elemen: Pilih elemen pertama dari “bagian yang belum

diurutkan”.

3. Bandingkan dengan Elemen Sebelumnya: Bandingkan elemen yang

dipilih dengan elemen sebelumnya di “bagian yang sudah diurutkan”.
Jika elemen yang dipilih lebih kecil, tukar posisi mereka.

4. Iterasi: Lanjutkan proses ini dengan elemen berikutnya di “bagian

yang belum diurutkan”, dan ulangi langkah 3 sampai kita menemukan
elemen yang lebih besar atau mencapai awal array.

5. Ulangi Langkah 2-4: Ulangi langkah 2 sampai 4 untuk seluruh array

sampai seluruh array diurutkan.

Gambar 2.2.1 Ilustrasi Insertion Sort

Proses Algoritma Insertion Sort berdasarkan gambar :

1. Baris pertama menunjukkan array yang belum diurutkan.
2. Baris kedua menunjukkan subarray yang diurutkan dan subarray yang
belum diurutkan.

4
 3. Baris ketiga menunjukkan perbandingan antara elemen saat ini dan
elemen pertama dalam subarray yang diurutkan.
4. Baris keempat menunjukkan pergeseran elemen-elemen dalam
subarray yang diurutkan.
5. Baris kelima menunjukkan penyisipan elemen saat ini ke posisinya
yang benar dalam subarray yang diurutkan.

2.2.2 Selection Sort

Selection sort membandingkan elemen saat ini dengan yang berikutnya
hingga akhir, mencatat elemen yang lebih kecil dan menukarnya. Pendekatan
ini memilih nilai terkecil, memindahkannya ke posisi awal, dan terus
membandingkan elemen hingga tidak ada pertukaran data lagi (Yahya, 2014).

Proses dari Selection Sort :

1. Langkah 1: Melakukan iterasi dari elemen pertama hingga
elemen sebelum elemen terakhir:
a. Pilih elemen saat ini sebagai elemen terkecil.
b. Bandingkan elemen terkecil dengan elemen lain di
sebelahnya.
c. Jika ditemukan elemen yang lebih kecil, catat posisinya
sebagai elemen terkecil.
2. Langkah 2: Setelah menemukan elemen terkecil dari sisa daftar,
tukar elemen terkecil tersebut dengan elemen pertama dari sisa
daftar.
3. Langkah 3: Lanjutkan proses ini dengan mengambil elemen
kedua sebagai elemen terkecil dan mencari elemen terkecil di
sisa daftar, lalu tukar dengan elemen kedua. Lakukan hal ini
hingga semua elemen sudah terurut.
4. Langkah 4: Proses akan berakhir saat semua elemen sudah
terurut.

5
 Gambar 2.2.2 Visualisasi Selection Sort

2.2.3 Shell Sort

Shell Sort adalah cara untuk mengurutkan daftar bilangan atau abjad.
Mari kita bayangkan kita memiliki daftar nama yang harus kita urutkan dari
yang huruf pertama ke yang terakhir.
Proses Algoritma dari Shell Sort :
1. Ambil daftar nama yang ingin diurutkan. Misalkan kita punya daftar
nama seperti “Lisa”, “Warik”, “Davy”, “Liza”, “Aura”, dan
“Febriyanti”.
2. Jarak awal : Pilih suatu angka sebagai jarak awal, misalnya, setengah
dari jumlah nama. Ini seperti membuat sub-kelompok dari setengah
nama pertama, setengah nama kedua, dan seterusnya. Awalnya, kita
mungkin membagi nama menjadi dua sub-kelompok: {“Lisa”,
“Warik”, “Davy”} dan {“Liza”, “Aura”,“Febriyanti”}.
3. Urutkan Setiap Sub-Daftar : Ambil sub-kelompok yang memiliki jarak
tersebut, dan urutkan namanya menggunakan metode pengurutan sisip.
Pengurutan sisip adalah cara sederhana untuk menyusun nama-nama
dalam suatu daftar. Lakukan hal ini untuk setiap sub-kelompok.
Misalnya, kita urutkan setiap sub-kelompok: {"Davy", "Lisa",
"Warik"} dan {"Aura", "Febriyanti", "Liza"}.
4. Kurangi Jarak dan Ulangi :

6
 ● Kurangi nilai jarak menjadi setengah dari nilai sebelumnya.
Langkah selanjutnya, kita mungkin membagi setiap
sub-kelompok menjadi dua lagi: {"Davy"} dan {"Lisa",
"Warik"}. Kemudian kita urutkan lagi.
● Ulangi langkah kedua untuk sub-kelompok yang baru.
● Lakukan ini berulang-ulang sampai jarak menjadi satu.
5. Urutkan Sekali Lagi : Setelah jarak menjadi satu, lakukan pengurutan
sisip lagi pada seluruh daftar nama. Ini akan memastikan bahwa daftar
nama telah diurutkan sepenuhnya.

Jadi, intinya, Shell Sort mengurutkan daftar dengan cara membuat

sub-daftar yang lebih kecil dan mengurutkannya terlebih dahulu, kemudian
secara bertahap menggabungkannya kembali sambil terus mengurutkan. Ini
membantu meningkatkan kecepatan pengurutan, terutama pada daftar yang
hampir terurut.

Contoh sederhana bisa seperti mengurutkan daftar nama orang

berdasarkan abjad. Kita bisa memilih setengah daftar pertama, urutkan
nama-nama di dalamnya, kemudian gabungkan kembali dengan setengah
daftar berikutnya. Terus lakukan ini hingga semua nama terurut dengan rapi.

2.2.4 Merge Sort

Merge sort adalah algoritma pengurutan data yang bekerja dengan cara
membagi data menjadi dua bagian yang lebih kecil, kemudian mengurutkan
masing-masing bagian tersebut, dan menggabungkan kedua bagian tersebut
menjadi satu bagian yang terurut. Untuk mengimplementasikan struktur data
merge sort, kita dapat menggunakan sebuah array untuk menyimpan data yang
akan diurutkan.
Proses Algoritma dari Merge Sort :
1. Inisialisasi. Pertama, kita perlu menginisialisasi
variabel-variabel yang akan digunakan dalam algoritma merge
sort. Variabel-variabel tersebut biasanya adalah :
● data : Array yang menyimpan data yang akan diurutkan.
● awal : Indeks awal dari data yang akan diurutkan.
● akhir : Indeks akhir dari data yang akan diurutkan.
2. Pembagian. Jika panjang data lebih dari 1, maka kita membagi
data menjadi dua bagian yang sama panjang. Pembagian ini
dilakukan secara rekursif.
3. Pengurutan. Masing-masing bagian kemudian diurutkan
menggunakan algoritma merge sort.
4. Penggabungan. Setelah masing-masing bagian diurutkan,
maka kedua bagian tersebut digabungkan menjadi satu bagian
yang terurut.

7
 Gambar 2.2.4 Visualisasi Merge Sort

2.2.5 Heap Sort

Heap merupakan struktur data dalam bentuk pohon biner lengkap yang
mematuhi sifat heap. Pohon biner lengkap sendiri adalah pohon biner di mana
setiap levelnya terisi sepenuhnya kecuali level terakhir (Trivusi, 2023).
Elemen terbesar berada di akar pohon, sementara kedua anaknya lebih kecil
dari akar, dan pola ini berlanjut ke bawah. Jika kondisinya terbalik, di mana
semua simpul lebih kecil dari anak-anaknya, itu disebut sebagai min-heap.

Proses Algoritma dari Heap Sort:

1. Ubah array menjadi struktur heap maksimum dengan
memastikan setiap simpul memiliki nilai lebih besar dari
anak-anaknya.
2. Mengurutkan Array:
a. Ambil elemen terbesar (root heap), pindahkan ke akhir
array yang belum terurut, dan kurangi ukuran heap.
b. Perbaiki sisa array sebagai heap maksimum dengan
melakukan langkah heapify.
3. Proses Berulang: Ulangi langkah kedua hingga seluruh array
terurut.
4. Hasil Akhir: Setelah proses selesai, array diurutkan dari yang
terkecil ke yang terbesar atau sebaliknya, tergantung pada tipe
heap yang digunakan.

2.2.6 Bubble Sort

Bubble sort adalah salah satu algoritma pengurutan data yang paling
sederhana. Algoritma ini bekerja dengan cara membandingkan dua elemen

8
 data yang berdekatan dan menukar posisinya jika elemen pertama lebih besar
dari elemen kedua. Proses ini dilakukan secara berulang dari elemen pertama
hingga elemen terakhir. Untuk mengimplementasikan struktur data bubble
sort, kita dapat menggunakan sebuah array untuk menyimpan data yang akan
diurutkan.
Proses Algoritma dari Bubble Sort :
1. Inisialisasi. Pertama, kita perlu menginisialisasi
variabel-variabel yang akan digunakan dalam algoritma bubble
sort. Variabel-variabel tersebut biasanya adalah :
● data : Array yang menyimpan data yang akan diurutkan.
● i : Variabel iterasi untuk loop luar.
● j : Variabel iterasi untuk loop dalam.
● temp : Variabel untuk menyimpan data yang akan
ditukar.
2. Perulangan. Proses bubble sort dilakukan dengan dua loop for.
Loop luar digunakan untuk iterasi ke setiap elemen data. Loop
dalam digunakan untuk membandingkan dua elemen data yang
berdekatan. Jika elemen pertama lebih besar dari elemen kedua,
maka kedua elemen tersebut ditukar posisinya.
3. Periksa kondisi. Setelah loop dalam selesai, kita perlu
memeriksa kondisi apakah masih ada pertukaran data yang
terjadi. Jika tidak ada pertukaran data yang terjadi, maka proses
bubble sort sudah selesai.

2.2.7 Graf
Sebuah graf G didefinisikan sebagai pasangan himpunan (V,E) , dengan
V adalah himpunan tak kosong dari simpul-simpul (vertices) pada G.
Sedangkan E adalah himpunan rusuk (edge) pada G yang menghubungkan
sepasang simpul. Himpunan simpul pada G dinotasikan sebagai V, dan
himpunan rusuk pada G dinotasikan sebagai E. Jadi G=(V, E) (Harju, 2012).

Proses dari Graf :

1. Langkah Pertama: Tentukan Himpunan Simpul (Vertices) V dan
Himpunan Rusuk (Edges) E.
- Misalnya, kita ingin membuat graf dengan 4 simpul dan 5 rusuk.

V = {A, B, C, D}
E = {(A, B), (B, C), (C, D), (D, A), (A, C)}

2. Langkah Kedua: Gambarkan Simpul-simpul pada Graf.

- Setiap elemen dalam himpunan V direpresentasikan sebagai simpul
pada graf.

3. Langkah Ketiga: Sambungkan Simpul-simpul dengan Rusuk.

9
 - Setiap pasangan simpul dalam himpunan E direpresentasikan sebagai
rusuk yang menghubungkan simpul-simpul tersebut.

4. Langkah Keempat: Visualisasi Graf secara Lengkap.

- Gabungkan simpul dan rusuk untuk membentuk graf secara lengkap.

2.3 Implementasi Program

2.3.1 Insertion Sort
Input Program Java Insertion Sort
public class InsertionSortPerson {
static class Orang {
String nama;
int usia;

Orang(String nama, int usia) {

this.nama = nama;
this.usia = usia;
}
}

public static void main(String[] args) {

Orang[] orangArray = {
new Orang("Liza", 20),
new Orang("Lisa", 22),
new Orang("Aura", 19),
new Orang("Varian", 18),
new Orang("Davy", 21)
};

System.out.println("Array sebelum diurutkan:");

cetakArray(orangArray);

insertionSort(orangArray);

System.out.println("\nArray setelah diurutkan berdasarkan usia:");

cetakArray(orangArray);
}

static void insertionSort(Orang[] arr) {

int n = arr.length;
for (int i = 1; i < n; ++i) {
Orang kunci = arr[i];
int j = i - 1;

10
 // Pindahkan elemen dari arr[0..i-1] yang lebih besar dari kunci
// ke posisi satu langkah di depan dari posisi sekarang
while (j >= 0 && arr[j].usia > kunci.usia) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = kunci;
}
}

static void cetakArray(Orang[] arr) {

int n = arr.length;
for (int i = 0; i < n; ++i) {
System.out.println("Nama: " + arr[i].nama + ", Usia: " +
arr[i].usia);
}
}
}

Output Program Java Insertion Sort

Penjelasan Program Java Insertion Sort

1. Kelas 'Orang':
● Program ini mendefinisikan kelas Orang yang memiliki dua atribut:
nama dan usia.
● Terdapat sebuah konstruktor di dalam kelas Orang untuk membuat
objek Orang dengan memberikan nilai awal untuk nama dan usia.
2. Metode main:

11
 ● Dalam metode main, array dibuat dari objek Orang dengan beberapa
data uji.
● Mencetak array sebelum diurutkan menggunakan metode cetakArray.
3. Metode insertionSort:
● Metode ini menerima array dari objek Orang sebagai parameter dan
mengurutkannya berdasarkan usia menggunakan algoritma Insertion
Sort.
● Iterasi dilakukan dari elemen kedua hingga elemen terakhir array.
● Selama iterasi, elemen saat ini dibandingkan dengan elemen-elemen
sebelumnya, dan jika usianya lebih kecil, elemen-elemen tersebut
bergeser ke posisi berikutnya untuk memberikan tempat bagi elemen
saat ini.
4. Metode cetakArray:
● Metode ini menerima array dari objek Orang sebagai parameter dan
mencetak nama dan usia setiap objek dalam array.

2.3.2 Selection Sort

Input Program Java Selection Sort
public class SelectionSort {
// Fungsi untuk melakukan Selection Sort pada array
public static void selectionSort(int[] arr){
for (int i = 0; i < arr.length - 1; i++)
{
int index = i;
// Mencari indeks terkecil
for (int j = i + 1; j < arr.length; j++){
if (arr[j] < arr[index]){
index = j;// Mencari indeks terkecil
}
}
// Menukar nilai terkecil dengan nilai saat ini pada iterasi
int smallerNumber = arr[index];
arr[index] = arr[i];
arr[i] = smallerNumber;
}
}

public static void main(String a[]){

// Array yang akan diurutkan
int[] arr1 = {9,14,3,2,43,11,58,22};

12
 // Output sebelum pengurutan
System.out.println("Sebelum Selection Sort");
for(int i:arr1){
System.out.print(i+" ");
}
System.out.println();

selectionSort(arr1);// Mengurutkan array menggunakan Selection Sort

// Output sesudah pengurutan
System.out.println("Setelah Selection Sort");
for(int i:arr1){
System.out.print(i+" ");
}
}
}

Output Program Java Selection Sort

Penjelasan Program Java Selection Sort

Kelas SelectionSort:
● Mendefinisikan kelas yang mengimplementasikan algoritma Selection
Sort.
● Memiliki fungsi selectionSort yang digunakan untuk melakukan
Selection Sort pada array yang diberikan.
● Fungsi selectionSort berisi langkah-langkah Selection Sort, dimulai
dari pencarian nilai terkecil, menukar nilai terkecil dengan nilai saat ini
pada iterasi, dan berlanjut hingga pengurutan selesai.
Fungsi main:
● Merupakan titik masuk program, dimana eksekusi program dimulai.
● Mencetak array sebelum dilakukan pengurutan (sebelum Selection
Sort).
● Memanggil fungsi selectionSort untuk mengurutkan array
menggunakan Selection Sort.

13
 ● Setelah pengurutan selesai, mencetak array yang sudah diurutkan
(setelah Selection Sort).

2.3.3 Shell Sort

Input Program Java Shell Sort
public class ShellSort {

public static void main(String[] args) {

// Daftar nama sebelum diurutkan
String[] unsortedNames = {"Lisa", "Warik", "Davy", "Liza",
"Aura", "Febriyanti"};

System.out.println("Daftar Nama Sebelum Diurutkan:");

printArray(unsortedNames);

// Panggil metode Shell Sort

shellSort(unsortedNames);

System.out.println("\nDaftar Nama Setelah Diurutkan:");

printArray(unsortedNames);
}

// Metode untuk mengurutkan array menggunakan Shell Sort

public static void shellSort(String[] arr) {
int n = arr.length;
int gap = n / 2;

while (gap > 0) {

for (int i = gap; i < n; i++) {
String temp = arr[i];
int j = i;

while (j >= gap && arr[j - gap].compareTo(temp) > 0) {

arr[j] = arr[j - gap];
j = j - gap;
}

arr[j] = temp;
}

gap = gap / 2;
}
}

14
 // Metode untuk mencetak array
public static void printArray(String[] arr) {
for (String name : arr) {
System.out.print(name + " ");
}
System.out.println();
}
}

Output Program Java Shell Sort

Penjelasan Program Java Shell Sort

Kelas ShellSort :
Program Java di atas adalah implementasi dari algoritma Shell Sort
untuk mengurutkan daftar nama. Mari jelaskan fungsi-fungsi yang ada dalam
program tersebut dengan bahasa yang mudah dimengerti:

● Mendefinisikan kelas Shell Sort yang mengandung implementasi

algoritma shell sort.
● Metode ini menerapkan algoritma Shell Sort untuk mengurutkan array
dari string (nama).
● Menerima parameter array yang akan diurutkan.
● Variabel gap diinisialisasi sebagai setengah dari panjang array.
Dilakukan pengurutan menggunakan konsep subarray dengan jarak
gap.
● Iterasi dilakukan hingga gap menjadi 0, dan setiap iterasi mengurutkan
subarray dengan jarak yang semakin kecil.

Fungsi Main :

● Fungsi utama yang dijalankan pertama kali saat program dijalankan.

● Inisialisasi array unsortedNames dengan daftar nama yang akan
diurutkan.
● Mencetak daftar nama sebelum diurutkan menggunakan metode
printArray.
● Memanggil metode shellSort untuk mengurutkan daftar nama.

15
 ● Mencetak daftar nama setelah diurutkan menggunakan metode
printArray.
Dengan menggunakan fungsi-fungsi ini, program melakukan
pengurutan daftar nama menggunakan algoritma Shell Sort dan mencetak
daftar nama sebelum dan sesudah diurutkan. Semua langkah-langkah tersebut
diatur dalam fungsi-fungsi yang tersusun rapi dalam kelas ShellSort.

2.3.4 Merge Sort

Input Program Merge Sort
public class MergeSort {

public static void mergeSort(int[] arr) {

if (arr == null || arr.length <= 1) {
return;
}
sort(arr, 0, arr.length - 1);
}

private static void merge(int[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int[] leftArr = new int[n1];
int[] rightArr = new int[n2];
for (int i = 0; i < n1; ++i) {
leftArr[i] = arr[left + i];
}
for (int j = 0; j < n2; ++j) {
rightArr[j] = arr[mid + 1 + j];
}
int i = 0, j = 0;
int k = left;

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

if (leftArr[i] <= rightArr[j]) {
arr[k] = leftArr[i];
i++;
} else {
arr[k] = rightArr[j];
j++;
}
k++;
}

while (i < n1) {

16
 arr[k] = leftArr[i];
i++;
k++;
}

while (j < n2) {

arr[k] = rightArr[j];
j++;
k++;
}
}

private static void sort(int[] arr, int left, int right) {

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

sort(arr, left, mid);

sort(arr, mid + 1, right);

merge(arr, left, mid, right);

}
}
}
class MainMergeSort {

public static void main(String[] args) {

int[] data = {21, 16, 10, 9, 3, 7};

System.out.println("Array sebelum diurutkan:");

printArray(data);

MergeSort.mergeSort(data);

System.out.println("\nArray setelah diurutkan:");

printArray(data);
}
public static void printArray(int[] array) {
for (int i : array) {
System.out.print(i + " ");
}
System.out.println();
}
}

17
 Output Program Merge Sort

Penjelasan Merge Sort

Kelas Merge Sort :
● jika array null atau memiliki satu elemen atau kurang, maka langsung
kembali tanpa melakukan apapun. Jika kondisi tersebut tidak
terpenuhi, maka metode sort dipanggil untuk melakukan pengurutan.
● menggabungkan dua bagian yang terurut menjadi satu bagian yang
terurut.
● memecah array menjadi bagian-bagian yang lebih kecil hingga
mencapai kondisi dasar (hanya satu elemen) kemudian melakukan
penggabungan kembali dengan metode merge.

Fungsi Main :
● Mencetak array sebelum dilakukan pengurutan menggunakan
algoritma Merge Sort.
● Memanggil fungsi MergeSort dari kelas MergeSort untuk
mengurutkan array yang telah diberikan.
● Setelah proses pengurutan selesai, mencetak array yang sudah
diurutkan menggunakan algoritma Merge Sort.

2.3.5 Heap Sort

Input Program Java Heap Sort
public class HeapSort {
// Fungsi utama untuk mengurutkan array menggunakan Heap Sort
public void sort(int arr[]) {
int n = arr.length;

// Langkah 1: Membangun heap

for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);

// Langkah 2: Mengeluarkan elemen dari heap satu per satu

for (int i = n - 1; i >= 0; i--) {
// Pindahkan elemen saat ini (root) ke bagian terakhir array

18
 int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;

// Panggil heapify untuk heap yang berkurang

heapify(arr, i, 0);
}
}

// Pembentukan heap
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

// Periksa apakah anak kiri atau kanan lebih besar dari root
if (left < n && arr[left] > arr[largest])
largest = left;

if (right < n && arr[right] > arr[largest])

largest = right;

// Jika largest bukan root, tukar dengan root dan rekursif heapify
sub-pohon yang terpengaruh
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;

heapify(arr, n, largest);
}
}

// Fungsi untuk mencetak array

static void printArray(int arr[]) {
int n = arr.length;
for (int i = 0; i < n; ++i)

19
 System.out.print(arr[i] + " ");
System.out.println();
}

// Program utama
public static void main(String args[]) {
// Array yang akan diurutkan
int arr[] = { 12, 11, 13, 5, 6, 7 };
int n = arr.length;

// Output sebelum pengurutan

System.out.println("Array sebelum pengurutan:");
printArray(arr);

// Proses pengurutan menggunakan Heap Sort

HeapSort ob = new HeapSort();
ob.sort(arr);

// Output setelah pengurutan

System.out.println("Array yang Diurutkan:");
printArray(arr);
}
}

Output Program Java Heap Sort

Penjelasan Program Java Heap Sort

Kelas HeapSort:
● Mendefinisikan kelas HeapSort yang mengandung implementasi
algoritma Heap Sort.
● Fungsi sort digunakan untuk mengurutkan array dengan Heap Sort.
Prosesnya terfokus pada dua langkah utama: pertama, membangun
heap maksimum dari array melalui iterasi; kedua, mengekstraksi
elemen dari heap dengan menukar elemen pertama (root) dengan

20
 elemen terakhir di array, menjaga sisa array agar tetap
mempertahankan sifat heap.
● Fungsi heapify membentuk dan memelihara sifat heap pada array,
memeriksa nilai elemen anak dan induk dalam sub-pohon. Jika ada
ketidaksesuaian, dilakukan pertukaran dan rekursi pada sub-pohon
untuk memastikan sifat heap terjaga.
● Fungsi printArray: Digunakan untuk mencetak isi array.
Fungsi main:
● Program utama dimulai di sini.
● Mencetak array sebelum pengurutan.
● Membuat objek HeapSort, kemudian melakukan pengurutan array
menggunakan fungsi sort().
● Mencetak array setelah pengurutan.

2.3.6 Bubble Sort

Input Program Bubble Sort
public class BubbleSort {

public static 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]) {
// Menukar elemen jika tidak terurut
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
class MainBubbleSort {

public static void main(String[] args) {

int[] data = {76, 38, 22, 11, 29, 9, 95};

System.out.println("Array sebelum diurutkan:");

printArray(data);

BubbleSort.bubbleSort(data);

System.out.println("\nArray setelah diurutkan:");

printArray(data);

21
 }

public static void printArray(int[] array) {

for (int i : array) {
System.out.print(i + " ");
}
System.out.println();
}
}

Output Program Bubble Sort

Penjelasan Bubble Sort

Kelas Bubble Sort :
● melakukan pengurutan menggunakan algoritma Bubble Sort.
Algoritma ini bekerja dengan membandingkan elemen-elemen secara
berpasangan dan menukar mereka jika tidak terurut, sehingga
elemen-elemen terbesar bergerak ke ujung kanan array secara bertahap.
Fungsi Main :
● Fungsi ini merupakan titik masuk program. Pada awalnya, mencetak
array sebelum dilakukan pengurutan.
● Memanggil metode bubbleSort dari kelas BubbleSort untuk
mengurutkan array yang diberikan.
● Setelah proses pengurutan selesai, mencetak array yang sudah
diurutkan.

2.3.7 Graf
Input Program Java Graf
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;

class Graph extends JFrame {

private final ArrayList<Point> points;

public Graph(ArrayList<Point> points) {

22
 this.points = points;

setTitle("Graph Example");
setSize(400, 400);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}

@Override
public void paint(Graphics g) {
super.paint(g);

// Menggambar graf
for (Point point : points) {
drawPoint(g, point);
}

// Menggambar garis antara titik

g.setColor(Color.RED);
for (int i = 0; i < points.size() - 1; i++) {
Point p1 = points.get(i);
Point p2 = points.get(i + 1);
g.drawLine(p1.x, p1.y, p2.x, p2.y);
}

// Menghubungkan titik terakhir kembali ke titik pertama untuk

membentuk segitiga
Point firstPoint = points.get(0);
Point lastPoint = points.get(points.size() - 1);
g.drawLine(lastPoint.x, lastPoint.y, firstPoint.x, firstPoint.y);
}

private void drawPoint(Graphics g, Point point) {

int pointSize = 8;
g.setColor(Color.BLUE);
g.fillOval(point.x - pointSize / 2, point.y - pointSize / 2, pointSize,
pointSize);

23
 }

public static void main(String[] args) {

SwingUtilities.invokeLater(() -> {
ArrayList<Point> points = new ArrayList<>();
points.add(new Point(50, 100));
points.add(new Point(150, 200));
points.add(new Point(250, 50));

new Graph(points);
});
}
}

Output Program Java Graf

Penjelasan Program Java Graf

Kelas Graph:
● Kelas ini merupakan turunan dari kelas JFrame, yang digunakan
untuk membuat jendela GUI.
● Memiliki atribut private final ArrayList<Point> points untuk
menyimpan kumpulan objek Point.

24
 ● Konstruktor Graph(ArrayList<Point> points) menerima kumpulan
objek Point dan menginisialisasi atribut points. Selain itu, konstruktor
ini mengatur beberapa properti jendela seperti judul, ukuran, dan
lokasi.
● Metode paint(Graphics g) digunakan untuk menggambar grafik di
jendela. Metode ini menggambar titik-titik dan menghubungkannya
dengan garis untuk membentuk segitiga.
● Metode drawPoint(Graphics g, Point point) digunakan untuk
menggambar titik pada koordinat yang diberikan.

Metode main:
● Metode ini merupakan metode utama yang dipanggil saat program
dijalankan.
● Menggunakan SwingUtilities.invokeLater untuk memastikan bahwa
pembuatan GUI dilakukan pada thread AWT event dispatch, yang
disarankan untuk operasi GUI.
● Membuat objek Graph dengan mengirimkan kumpulan objek Point
sebagai argumen konstruktor.

Kelas Point:
● Tidak didefinisikan di dalam potongan kode yang diberikan, tetapi
diasumsikan bahwa ini adalah kelas bawaan Java Point atau kelas
sederhana yang memiliki dua atribut x dan y untuk menyimpan
koordinat titik.

25
 BAB III
PENUTUP

3.1 Kesimpulan
Konsep computational thinking memainkan peran kunci dalam pengembangan
solusi-solusi efektif untuk mengelola, mencari, menyimpan, dan memproses data
dengan kompleksitas tinggi. Kemampuan untuk memecahkan masalah, merancang
algoritma, dan berpikir secara logis menjadi landasan penting dalam mengatasi
tantangan pengolahan data yang kompleks. Penerapan struktur data yang tepat dan
algoritma pengurutan yang efisien memberikan dampak positif terhadap kinerja
aplikasi dalam pengelolaan data, dengan fokus pada efisiensi dan akurasi manipulasi
data. Penggunaan representasi data dalam bentuk graf juga terbukti efektif sebagai
metode untuk memodelkan hubungan antar entitas, mendukung analisis mendalam
terhadap interaksi antar elemen dalam berbagai konteks pengolahan data. Oleh karena
itu, pemahaman konsep computational thinking, pilihan struktur data, dan
implementasi algoritma yang cermat merupakan aspek-aspek krusial untuk
menghadapi tantangan kompleks dalam pengolahan data dengan baik dan efisien.

3.2 Saran
Dari hasil implementasi yang telah dilakukan, beberapa saran dapat diajukan
untuk lebih memperbaiki pengelolaan data dan pengembangan solusi yang lebih
efektif.
1. Penting untuk terus mengembangkan keterampilan computational thinking,
seperti kemampuan pemecahan masalah dan pemikiran algoritmik, melalui
pendidikan formal dan pelatihan tambahan.
2. Penelitian dan implementasi algoritma pengurutan serta struktur data yang
efisien perlu diperhatikan secara terus-menerus guna meningkatkan kinerja
aplikasi pada pengelolaan data.
3. Penerapan prinsip-prinsip desain perangkat lunak yang baik, terutama dalam
pemilihan struktur data yang sesuai, dapat memberikan dukungan yang kuat
terhadap efektivitas dan skalabilitas solusi.
4. Penggunaan graf sebagai representasi data dapat lebih ditekankan untuk
mendukung analisis interaksi antar entitas dalam berbagai konteks,
memungkinkan pemahaman yang lebih baik terhadap struktur dan dinamika
data.

26
 Dengan demikian, penerapan dan peningkatan pemahaman terhadap
konsep-konsep ini akan menjadi kunci dalam menghadapi kompleksitas pengolahan
data dengan lebih efisien dan akurat.

27
 DAFTAR PUSTAKA

Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms
(3rd ed.). MIT Press.
Knuth, D. E. (1998). The Art of Computer Programming, Volume 3: Sorting and Searching
(2nd ed.). Addison-Wesley.
Newman, M. (2003). The structure and function of complex networks. SIAM Review, 45(2),
167–256.
Resnick, M. (2017). Lifelong kindergarten: Cultivating creativity through projects, passion,
peers, and play. MIT Press.
Abdullah, M. F., Hafiza, I., Wahyuni, R., & Syahputra, A. (2023). Penggunaan Algoritma
Bubble Sort dalam Pengurutan Nomor Induk Mahasiswa. Hello World Jurnal Ilmu
Komputer, 2(1), 14-19.
Sunandar, E., & Indrianto, I. (2020). Implementasi Algoritma Bubble Sort Terhadap 2 Buah
Model Varian Pengurutan Data Menggunakan Bahasa Program Java.
Marwa, S. (2022). Aplikasi Algoritma Pengurutan Menggunakan Java BlueJ Sebagai Media
Bantu Pembelajaran. Journal of Engineering Science and Technology Management
(JES-TM), 2(2), 124-129.
Retnoningsih, E. (2018). Algoritma Pengurutan Data (Sorting) Dengan Metode Insertion Sort
dan Selection Sort. Information Management For Educators And Professionals:
Journal of Information Management, 3(1), 95-106.

28
 LAMPIRAN

Video Presentasi Demo Program

https://drive.google.com/drive/folders/1j8GpdqvXWVSnBENlmz9dNQPW24nz0cf-?usp=sh
aring

File Program Java

https://drive.google.com/drive/folders/1j8GpdqvXWVSnBENlmz9dNQPW24nz0cf-?usp=sh
aring

29