MAKALAH

SORTING
“Disusun Untuk Memenuhi Tugas Mata Kuliah Struktur Data”

DISUSUN OLEH:
GHENTA RISKY LAMUSA
NIM 2522.298

DOSEN PEMBIMBING
Yulifda Elin Yuspita, M.Kom

JURUSAN S1 PENDIDIKAN TEKNIK INFORMATIKA DAN KOMPUTER

FAKULTAS TARBIYAH DAN ILMU KEGURUAN
UIN SJECH M.DJAMIL DJAMBEK BUKITTINGGI
TAHUN AJARAN
2022/2023
 KATA PENGANTAR
Assalamu’alaikum Wr. Wb
Alhamdulillah, segala puji hanya milik Allah SWT yang senantiasa melimpahkan
rahmat,karunia dan hidayah – Nya kepada kita semua sehingga kita bisa melakukan aktivitas
kita dengan baik, sehat wal‘afiat khususnya kepada penulis sehingga makalah yang berjudul
“Sorting” ini bisa diselesaikan dengan baik. Tidak lupa pula kami ucapkan terima kasih
kepada Ibuk “Yulifda Elin Yuspita,M.Kom” selaku dosen pembimbing dalam mata kuliah
Struktur Data yang telah membimbing dan mengarahkan penulis dalam menyelesaikan
makalah ini.
Penulis sangat mengharapkan kritik dan saran dari pembaca untuk kemudian makalah kami
ini dapat kami perbaiki dan menjadi lebih baik lagi
Penulis menyadari bahwa makalah ini belum baik dan masih jauh dari kesempurnanan.
Sehingga penulis meminta kritik dan saran dari pembaca. Agar penulisan selanjutnya bisa
lebih baik lagi.

Bukittinggi,27 April 2023

Penulis

i
 DAFTAR ISI

KATA PENGANTAR.......................................................................................................i
DAFTAR ISI.....................................................................................................................ii
BAB I PENDAHULUAN.................................................................................................1
A. Latar Belakang Masalah......................................................................................1
B. Rumusan Masalah................................................................................................2
C. Tujuan Pembahasan.............................................................................................2
BAB II PEMBAHASAN..................................................................................................3
A. Pengertian Sorting................................................................................................3
B. Selection Sort.........................................................................................................3
C. Insertion Sort........................................................................................................4
D. Bubble Sort............................................................................................................5
E. Quick Sort.............................................................................................................6
F. Merge Sort.............................................................................................................7
G. Heap Sort...............................................................................................................9
H. Implementasi Sorting Dalam Bahasa Pemrograman C++..............................10
BAB III PENUTUP.........................................................................................................20
A. Kesimpulan...........................................................................................................20
B. Saran.....................................................................................................................20
DAFTAR PUSTAKA......................................................................................................21

ii
iii
 BAB I
PENDAHULUAN
A. Latar Belakang Masalah
Dalam matematika dan komputasi, algoritma merupakan kumpulan perintah
untuk menyelesaikan suatu masalah. Perintah-perintah ini dapat diterjemahkan secara
bertahap dari awal hingga akhir. Masalah tersebut dapat berupa apa saja, dengan
catatan untuk setiap masalah, ada kriteria kondisi awal yang harus dipenuhi sebelum
menjalankan algoritma. Algoritma akan dapat selalu berakhir untuk semua kondisi
awal yang memenuhi kriteria, dalam hal ini berbeda dengan heuristik. Algoritma
sering mempunyai langkah pengulangan (iterasi) atau memerlukan keputusan (logika
Boolean dan perbandingan) sampai tugasnya selesai.
Desain dan analisis algoritma adalah suatu cabang khusus dalam ilmu komputer yang
mempelajari karakteristik dan performa dari suatu algoritma dalam menyelesaikan
masalah, terlepas dari implementasi algoritma tersebut. Dalam cabang disiplin ini
algoritma dipelajari secara abstrak, terlepas dari sistem komputer atau bahasa
pemrograman yang digunakan. Algoritma yang berbeda dapat diterapkan pada suatu
masalah dengan kriteria yang sama.
Kompleksitas dari suatu algoritma merupakan ukuran seberapa banyak komputasi
yang dibutuhkan algoritma tersebut untuk menyelesaikan masalah. Secara informal,
algoritma yang dapat menyelesaikan suatu permasalahan dalam waktu yang singkat
memiliki kompleksitas yang rendah, sementara algoritma yang membutuhkan waktu
lama untuk menyelesaikan masalahnya mempunyai kompleksitas yang tinggi.
Sedangkan sorting adalah sebuah proses merangkai benda dalam urutan tertentu
dan/atau dalam himpunan yang berbeda, dan oleh karena itu dia memiliki dua arti
umum yang berbeda:
1. Pengurutan: merangkai benda yang sejenis, sekelas, dll, dalam urutan yang
teratur.
2. Kategorisasi: pengelompokan dan pemberian label kepada benda dengan sifat
yang serupa.
algoritma sorting terdiri dari beberapa algoritma seperti Bubble sort, Quick sort,
Selection Sort, Insertion Sort, dan Merge Sort yang dimana setiap jenis sorting ini
memiliki perbedaan satu sama lainnya.

1
B. Rumusan Masalah
Adapun rumusan masalahnya yaitu :
1. Apa yang dimaksud dengan sorting?
2. Apa yang dimaksud dengan selection sort?
3. Apa yang dimaksud dengan insertion sort?
4. Apa yang dimaksud dengan bubble sort?
5. Apa yang dimaksud dengan quick sort?
6. Apa yang dimaksud dengan merge sort?
7. Apa yang dimaksud dengan heap sort?
8. Bagaimana implementasi sorting dalam Bahasa pemrograman C++?
C. Tujuan Pembahasan
Adapun tujuan pembahasannya yaitu :
1. Untuk mengetahui definisi sorting
2. Untuk mengetahui selection sort
3. Untuk mengetahui insertion sort
4. Untuk mengetahui bubble sort
5. Untuk mengetahui quick sort
6. Untuk mengetahui merge sort
7. Untuk mengetahui heap sort
8. Untuk mengetahui implementasi sorting dalam Bahasa pemrograman C++

2
 BAB II
PEMBAHASAN
A. Pengertian Sorting
Pengurutan (sorting) adalah proses mengatur sekumpulan objek menurut
urutan atau susunan tertentu. Urutan objek tersebut dapat menaik (ascending), yaitu
urutan objek yang disusun mulai dari Nilai terkecil hingga terbesar atau menurun
(descending), yaitu urutan objek yang disusun mulai dari Nilai terbesar hingga
terkecil. Jika N buah objek atau data disimpan di dalam array Nilai, maka pengurutan
menaik berarti menyusun elemen array sedemikian sehingga:

NILAI[0] ≤ NILAI[1] ≤ NILAI[2] ≤ … ≤ NILAI[N-1]

Sedangkan pengurutan menurun  berarti menyusun elemen array sedemikian

sehingga:

NILAI[0] ≥ NILAI[1] ≥ … ≥ NILAI[N-1]

Data yang diurut dapat berupa data bertipe data dasar atau tipe data bentukan. Jika
data bertipe bentukan (structure), maka harus disebutkan berdasarkan field apa data
tersebut akan diurutkan.

B. Selection Sort
Selection Sort adalah sort yang melakukan beberapa kali pass untuk
melakukan penyeleksian elemen struktur data. Untuk sorting ascending (menaik),
elemen yang paling kecil di antara elemen-elemen yang belum urut, disimpan
indeksnya, kemudian dilakukan pertukaran nilai elemen dengan indeks yang disimpan
tersebut dengan elemen yang paling depan yang belum urut. Sebaliknya, untuk sorting
descending (menurun), elemen yang paling  besar yang disimpan indeksnya kemudian
ditukar.

Algoritma selection sort dapat dirangkum sebagai berikut:

a) Temukan nilai yang paling minimum (atau sesuai keinginan) di dalam struktur
data. Jika ascending, maka yang harus ditemukan adalah nilai yang paling
minimum. Jika descending, maka temukan nilai yang paling maksimum.

3
 b) Tukar nilai tersebut dengan nilai pada posisipertama di bagian struktur data
yang belum diurutkan.
c) Ulangi langkah di atas untuk bagian struktur datayang tersisa.1

Pseudocode dari selection Sort adalah sebagai berikut;
  For I = 0 to N-1 do:
       Smallsub = I
       For J = I + 1 to N-1 do:
         If A(J) < A(Smallsub)
           Smallsub = J
         End-If
       End-For
       Temp = A(I)
       A(I) = A(Smallsub)
       A(Smallsub) = Temp
     End-For

C. Insertion Sort
Metode pengurutan pada insertion sort adalah metode dengan cara menyisipka
n elemen lari pada posisi yang tepat.Cara kerja insertion sort, Pertama-tama,
dilakukan iterasi, dimana disetiap iterasi insertion sort memindahkan nilai
elemen,kemudian menyisipkannya berulang-ulang sampai ketempat yang tepat.
Begitu seterusnya dilakukan.  Dari proses iterasi, seperti biasa, terbentuklah bagian
yang telah di-sorting dan bagian yang belum di-sorting.
Algoritma Insertion Sort dapat dirangkum sebagai berikut:
1) Simpan nilai Ti kedalam variabel sementara, dengan i = 1.
2) Bandingkan nilainya dengan elemen sebelumnya.
3) Jika elemen sebelumnya (Ti-1) lebih besar nilainya daripada Ti, maka tindih
nilai Ti dengan nilai Ti-1 tersebut. Decrement i (kurangi nilainya dengan 1).
4) Lakukan terus poin ke-tiga, sampai Ti-1 ≤ Ti.
5) Jika Ti-1 ≤ Ti terpenuhi, tindih nilai di Ti dengan variabel sementara yang
disimpan sebelumnya.
1
Endang Retnoningsih, ‘Algoritma Pengurutan Data (Sorting) Dengan Metode Insertion Sort Dan Selection
Sort’, Information Management for Educators and Professionals, 3.1 (2018), 95–106.

4
 6) Ulangi langkah dari poin 1 di atas dengan i di-increment (ditambah satu).

Pseudocode dari Insertion Sort adalah sebagai berikut;
procedure insertion;
   var i,j,v: integer;
   begin
for i:=2 to N do
begin
v:=a[i];j:=1;
while a[j1] > v do
 begin a[j]:=a[j1]; j:=j1 end;
a[j]:=v;
end
end;

D. Bubble Sort
Bubble Sort merupakan cara pengurutan yang sederhana. Konsep dari ide
dasarnya adalah seperti “gelembung air” untuk elemen struktur data yang semestinya
berada pada posisi awal. Cara kerjanya adalah dengan berulang-ulang melakukan
traversal (proses looping) terhadap elemen-elemen struktur datayang belum diurutkan.
Di dalam traversal tersebut, nilai dari dua elemen struktur data dibandingkan. Jika
ternyata urutannya tidak sesuai dengan “pesanan”, maka dilakukan pertukaran (swap).
Algoritma sortingini disebut juga dengan comparison sort dikarenakanhanya
mengandalkan perbandingan nilai elemen untuk mengoperasikan elemennya.
Algoritma bubble sort dapat diringkas sebagai berikut, jika N adalah panjang elemen
struktur data, dengan elemen-elemennya adalah T1, T2, T3, …, TN-1,TN, maka:
1) Lakukan traversal untuk membandingkan dua elemen berdekatan. Traversal ini
dilakukan dari belakang.
2) Jika elemen pada TN-1 > TN , maka lakukan pertukaran (swap). Jika tidak,
lanjutkan ke proses traversal berikutnya sampai bertemu dengan bagian
struktur data yang telah diurutkan.
3) Ulangi langkah di atas untuk struktur data yang tersisa.

Pseudocode dari bubble Sort adalah sebagai berikut;

5
   For I = 0 to N - 2
       For J = 0 to N - 2
         If (A(J) > A(J + 1)
           Temp = A(J)
           A(J) = A(J + 1)
           A(J + 1) = Temp
         End-If
       End-For
     End-For

E. Quick Sort
Quick Sort adalah algoritma sorting yang terkenal yang dirancang oleh C.A.R.
Hoare pada tahun 1960 ketika bekerja untuk perusahaan manufaktur komputer
saintifik kecil, Elliott Brothers. Algoritma ini rekursif, dan termasuk paradigma
algoritma divide and conquer.
Algoritma ini terdiri dari 4 langkah utama:
1) Jika struktur data terdiri dari 1 atau 0 elemen yang harus diurutkan, kembalikan
struktur data itu apa adanya.
2) Ambil sebuah elemen yang akan digunakansebagai pivot point (poin poros). 
(Biasanya elemen yang paling kiri.)
3) Bagi struktur data menjadi dua bagian – satu dengan elemen-elemen yang lebih
besar daripada pivot point, dan yang lainnya dengan elemen-elemen yang lebih
kecil dari pada pivot point.
4) Ulangi algoritma secara rekursif terhadap kedua paruh struktur data.

Berikut adalah tiga proses di dalam metode divide dan conqueror Quick Sort :
Divide :  Bagi array A[l..r] menjadi dua subarray A[l..pivot-1] dan
A[pivot+1..r] sehingga setiap elemen di dalam sub array A[l..pivot1] bernilai lebih
kecil atau sama dengan A[pivot]. Untuk menghitung nilai pivot merupakan
bagian dari prosedur partition.
Conqueror :  Urutkan subarray A[l..pivot1] dan A[pivot+1..r] secara rekursif ke
prosedur quicksort
Combine : Karena subarray sudah terurut, maka array A[l..r] sudah terurut.

6
 Pseudocode dari algoritma quick sort adalah sebagai berikut:
procedure quicksort(l,r:integer);
   var pivot: integer;
   begin
for r > l then
begin
 pivot:=partition(l,r);
 quicksort(l,pivot1);
 quicksort(pivot+1,r);
end
end;
Algoritma dari partisi array A[l..r] adalah :
x := A[r]
i := l-1
for j := l to r-1
do if A[j] <= x
then i := i + 1
exchange A[i] with A[j]
exchange A[i+1] with A[r]
return i+12

F. Merge Sort
Algoritma Merge Sort ditemukan oleh John vonNeumann di tahun 1945.
Merge Sort termasuk paradigma algoritma divide and conquer (kurang lebih berarti:
bagi dan atasi). Hal ini dikarenakan algoritma ini melakukan pembagian struktur data
sebelum kemudian dioperasi satu per satu. Intinya, algoritma ini menggunakan dua
ide utama sebagai berikut,
1) Sebuah list yang kecil membutuhkan langkah yang lebih sedikit untuk
pengurutan daripada sebuah list yang besar.
2) Untuk membentuk sebuah list terurut dari duabuah list terurut membutuhkan
langkah yangl ebih sedikit daripada membentuk sebuah list terurut dari dua

2
Roma Rio Sitepu, Machudor Yusman, and Febi Eka Febriansyah, ‘Implementasi Algoritma Bubble Sort Dan
Selection Sort Menggunakan Arraylist Multidimensi Pada Pengurutan Data Multi Prioritas’, Jurnal Komputasi,
5.1 (2017), 81–87 <https://doi.org/10.23960/komputasi.v5i1.1484>.

7
 buah list tak terurut. Contoh:hanya diperlukan satu kali traversal untuk
masing-masing list jika keduanya sudahterurut.
Algoritma Merge Sort sederhananya, dapat ditulis berikut:
1) Bagi list yang tak terurut menjadi dua sama panjang atau salah satunya lebih
panjang satu elemen.
2) Bagi masing-masing dari 2 sub-list secara rekursif sampai didapatkan list
dengan ukuran 1.
3) Gabung 2 sublist kembali menjadi satu list terurut.

Berikut ini adalah tiga proses di dalam menggunakan algoritma Merge Sort :
Divide :      Bagi array A[l..r] dengan jumlah elemen n menjadi dua subarray
dengan jumlah elemen masingmasing subarray sebanyak n/2.
Conqueror :     Urutkan masing-masing subarray secara rekursif menggunakan
prosedur merge sort
Combine :      Satukan subarray untuk menghasilkan elemen array A[l..r] yang
terurut.

Berikut ini adalah algoritma untuk Merge Sort array A[l..r] :
Merge-Sort (A,l,r)
  if l < r
     then q :=  [(l+r) /2]
     Merge-Sort(A,l,q)
     Merge-Sort(A,q+1,r)
     Merge(A,p,q,r)

Sedangkan algoritma untuk prosedure Merge adalah sebagai berikut :
MERGE ( A, l, q, r)
  n1 ← q − l + 1
  n2 ← r − q
  create arrays L[1 . . n 1 + 1] and R[1 . . n 2 + 1]
  for i ← 1 to n 1
          do L[i] ← A[ l + i − 1]
  for j ← 1 to n 2
          do R[ j ] ← A[q + j ]

8
   L[n 1 + 1] ← ∞
  R[n 2 + 1] ← ∞
i←1
j←1
for k ← l to r
          do if L[i] ≤ R[ j ]
                then A[k] ← L[i]
                      i ←i +1
                else A[k] ← R[ j ]
                       j ← j +1

G. Heap Sort
Heap sort adalah sebuah metode sorting (pengurutan) angka pada sebuah array
dengan cara menyerupai binary tree, yaitu dengan cara memvisualisasikan sebuah
array menjadi sebuah binary tree yang nantinya pada binary tree tersebut nilai pada
masing-masing index array akan diurutkan. Pada heap sort terdapat 3 bagian yaitu
Node , Edge , dan leaf dimana node itu adalah setiap index yang berada pada array,
edge adalah garis yang menghubungkan tiap node dan leaf adalah setiap node yang
tidak memiliki child node (node turunan). Selain itu juga ada yang bernama root yaitu
node awal pada sebuah heap, berikut adalah ilustrasi dari bagian yang dimiliki oleh
heap :

Heap tree terbagi menjadi 2 jenis yaitu Max- Heap dan Min-Heap, dimana max-heap
adalah kondisi heap tree yang memiliki nilai tertinggi berada di node root dan setiap
child node memiliki nilai yang lebih kecil dari nilai yang dimiliki parent nodenya.
Sedangkan pada min heap adalah kondisi kebalikan dengan max-heap, pada min-heap
nilai terkecil berada di node root dan setiap child node memiliki nilai yang lebih besar

9
 dari nilai yang dimiliki parent nodenya. Pada metode heap sort jenis heap tree yang
digunakan adalah Max-Heap.3

H. Implementasi Sorting Dalam Bahasa Pemrograman C++

1) Implementasi selection sort dalam pemrograman c++
#include <iostream>

using namespace std;

int main()
{
    int data[]={3,20,2,12,11};
int n=5,i,j,x,posisi,tampung;

cout<<"Sebelum Di Urutkan : ";

    for (int i=0; i<n; i++){
    cout<<data[i]<<" ";
  }
  
    cout<<endl;
    cout<<endl;
    
for (int i=0;i<n-1;++i){
   posisi=i;
   for (int j=i+1;j<n;++j){
    if (data[j]<data[posisi]){
         posisi=j;   
   }
   }

 
   if (posisi!=i){
         tampung=data[posisi];

3
Dosen Wayan Suparta, ‘INF202 : Struktur Data Pengurutan ( Sorting )’.

10
      data[posisi]=data[i];
     data[i]=tampung;
     }
    
   cout<<"Tahap Ke-"<<i+1<<" : ";
   for (int x=0;x<n;++x){
   cout<<data[x]<<" ";
   }
cout<<endl;
 }
 
  cout<<endl;
 
    cout<<"Setelah Di Urutkan Menggunakan Metode Selection Sort : ";
  for (int i=0;i<n;++i){
   cout<<data[i]<<" ";
   }  

}
output :

2) Implementasi insertion sort dalam pemrograman c++

#include<iostream>

using namespace std;

int main()
{
int x=5,i,tampung,j,k;
int data[]={4,12,3,30,1};

11
   
    cout<<"Data Sebelum Di Urutkan :";
    for(i=0;i<x;i++){
     cout<<"  "<<data[i];
  }
    cout<<endl;
    for(i=0;i<x;i++){
     for(j=0;j<i;j++){
        if(data[i]<data[j]){
           tampung=data[i];
             data[i]=data[j];
             data[j]=tampung;
}
       }
       cout<<"\n Tahap Ke-"<<i+1<<" : ";
       for(k=0;k<x;k++){
        cout<<"  "<<data[k];
       }
  }
    cout<<"\n\n Data Setelah Di Urutkan : ";
    for(i=0;i<x;i++){
     cout<<"  "<<data[i];
  }

}
Output:

3) Implementasi bubble sort dalam pemrograman c++

12
#include <iostream>
#include <conio.h>

using namespace std;

void prosesPerpindahan(int data[],int y){

int x;

for(x=0;x<y;x++){
cout<<data[x]<<" ";
}

cout<<endl;
}

void prosesSorting(int data[],int y){

int proses,x,tampung;

for(proses=1;proses<y;proses++){
for(x=0;x<y-proses;x++){
if(data[x]>data[x+1]){
tampung=data[x];
data[x]=data[x+1];
data[x+1]=tampung;
}
}
cout<<"Tahap Ke-"<<proses<<" : ";
prosesPerpindahan(data,y);
}

int main(){
int data[]={6,10,15,12,11};
int x;
const int jumlahdata=5;

prosesSorting(data,jumlahdata);

cout<<endl;
cout<<"Setelah Di Urutkan : "<<endl;
prosesPerpindahan(data,jumlahdata);

Output:

13
4) Implementasi quick sort dalam pemrograman c++
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>

void Cetak(int data[], int n)

{
int i;
for(i=0; i<n; i++)
cout<<setw(3)<<data[i];
cout<<"\n";
}

int Partisi(int data[], int p, int r)

{
int x, i, j, temp;
x = data[p];
i=p;
j=r;
while(l)
{
while(data[j]>x)
j--;
while(data[i]<x)
i++;
if(i<j)

14
 {
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
else
return j;
}
}

void Quick_Sort(int data[], int p, int r)

{
int q;
if(p<r)
{
q=Partisi(data, p, r+1);
Quick_Sort(data, p, 1);
Quick_Sort(data, q+1, r);
}
}

void main()
{
int Nilai[20];
int i, N;
cout<<"Masukkan Banyak Bilangan : ";
cin>>N;
for(i=0; i<N; i++)
{
cout<<"Elemen ke-"<<i<<" : ";
cin>>Nilai[i];
}

15
 cout<<"\nData Sebelum di urut : ";
Cetak(Nilai, N);
cout<<endl;
Quick_Sort(Nilai, 0, N-1);
cout<<"\nData Setelah di urut : ";
Cetak(Nilai,N);
getch();
}

5) Implementasi merge sort dalam pemrograman c++

#include <iostream>
using namespace std;

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

int n1 = mid - left + 1;
int n2 = right - mid;

int L[n1], R[n2];

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];
}

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

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

16
 if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {

arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

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

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

if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);

17
 }
}

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

for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int arr[] = { 38, 27, 43, 3, 9, 82, 10 };
int arrSize = sizeof(arr) / sizeof(arr[0]);

cout << "Array sebelum diurutkan:" << endl;

printArray(arr, arrSize);

mergeSort(arr, 0, arrSize - 1);

cout << "Array setelah diurutkan:" << endl;

printArray(arr, arrSize);

return 0;
}

6) Implementasi heap sort dalam pemrograman c++

#include <iostream>
using namespace std;
void heapify(int arr[], int n, int i)
{
int largest = i; int l = 2*i + 1;

18
int r = 2*i + 2;
if (l < n && arr[l] > arr[largest]) largest = l;
if (r < n && arr[r] > arr[largest]) largest = r;
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}}
void heapSort(int arr[], int n)
{
for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
for (int i=n-1; i>=0; i--)
{
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}}
int main() {
int n;
cout << "Masukkan jumlah elemen: ";
cin >> n;
int arr[n];
cout << "Masukkan elemen: ";
for(int i = 0; i < n; i++) { cin >> arr[i]; }
heapSort(arr, n);
cout << "Array setelah diurutkan: ";
for (int i=0; i<n; ++i) cout << arr[i] << " ";
return 0;
}4

BAB III
4
Endang Sunandar and Indrianto Indrianto, ‘Implementasi Algoritma Bubble Sort Terhadap 2 Buah Model
Varian Pengurutan Data Menggunakan Bahasa Program Java’, Petir, 13.2 (2020), 255–65
<https://doi.org/10.33322/petir.v13i2.1008>.

19
 PENUTUP
A. Kesimpulan
Algoritma yang mudah dalam hal implementasi adalah Bubble Sort, Selection
Sort, dan Insertion Sort. Ketiganya memiliki kompleksitas O(n2). Di antara algoritma
ini, yang paling effisien adalah Insertion Sort.  Algoritma yang lebih mangkus adalah
MergeSort dan Quick Sort dengan kompleksitasnya adalah O(n log n). Adapun yang
paling mangkus dari lima algoritma ini adalah Quick Sort.

B. Saran
Meskipun penulis menginginkan kesempurnaan dalam penyusunan makalah
ini, akan tetapi pada kenyataannya masih banyak kekurangan yang perlu penulis
perbaiki. Hal ini dikarenakan masih minimnya pengetahuan penulis.
Oleh karena itu kritik dan saran yang membangun dari para pembaca sangat
diharapkan sebagai bahan evaluasi untuk ke depannya. Sehingga bisa terus
menghasilkan penelitian dan karya tulis yang bermanfaat bagi banyak orang.

DAFTAR PUSTAKA

20
Retnoningsih, Endang, ‘Algoritma Pengurutan Data (Sorting) Dengan Metode Insertion Sort
Dan Selection Sort’, Information Management for Educators and Professionals, 3.1
(2018), 95–106
Rio Sitepu, Roma, Machudor Yusman, and Febi Eka Febriansyah, ‘Implementasi Algoritma
Bubble Sort Dan Selection Sort Menggunakan Arraylist Multidimensi Pada Pengurutan
Data Multi Prioritas’, Jurnal Komputasi, 5.1 (2017), 81–87
<https://doi.org/10.23960/komputasi.v5i1.1484>
Sunandar, Endang, and Indrianto Indrianto, ‘Implementasi Algoritma Bubble Sort Terhadap 2
Buah Model Varian Pengurutan Data Menggunakan Bahasa Program Java’, Petir, 13.2
(2020), 255–65 <https://doi.org/10.33322/petir.v13i2.1008>
Suparta, Dosen Wayan, ‘INF202 : Struktur Data Pengurutan ( Sorting )’

21