RESUME

ALGORITMA DAN PEMROGRAMAN DASAR

SORTING

A.MUHAMMAD FUAD FADHLURRAHMAN

220209501027
PTIK B

UNIVERSITAS NEGERI MAKASSAR

FAKULTAS TEKNIK
PENDIDIKAN TEKNIK INFORMATIKA DAN KOMPUTER
2022
Pengantar
• Penyortiran merujuk pada penyusunan sekumpulan data dalam beberapa
urutan logis
• Untuk mantan. Direktori telepon dapat dianggap sebagai daftar di mana
setiap catatan memiliki tiga bidang - nama, alamat, dan nomor telepon.
• Menjadi unik, nomor telepon dapat berfungsi sebagai kunci untuk
menemukan catatan apapun dalam daftar.
• Sorting adalah salah satu masalah yang paling mendasar dalam desain
algoritma.
• Kami diberi urutan item, masing-masing terkait dengan nilai kunci yang
diberikan. Dan masalahnya adalah mengatur ulang barang-barang itu agar
masuk urutan yang meningkat (atau menurun) dengan kunci.
• Metode penyortiran dapat dibagi menjadi dua kategori:
➢ Penyortiran Internal
➢ Penyortiran External

Penyortiran Internal
• Jika semua data yang akan diurutkan dapat disesuaikan sekaligus di
memori utama, maka metode pengurutan internal digunakan

Penyortiran Eksternal
• Bila data yang akan diurutkan tidak dapat ditampung dalam memori pada
saat yang sama dan sebagian harus disimpan dalam memori tambahan,
maka digunakan metode sortir eksternal.

CATATAN: Kami hanya akan mempertimbangkan penyortiran internal

Sortasi Stabil dan Tidak Stabil

Jika algoritme pengurutan, setelah mengurutkan konten, tidak mengubah
urutan konten serupa yang muncul, itu disebut stabil penyortiran.
 Jika algoritma pengurutan, setelah menyortir konten, mengubah urutan
konten serupa di mana mereka muncul, itu disebut tidak stabil
penyortiran.
Efisiensi Algoritma Sorting
• Kompleksitas algoritma pengurutan mengukur waktu berjalan dari suatu
fungsi di mana n jumlah item yang akan diurutkan.
• Pilihan metode pemilahan tergantung pada pertimbangan efisiensi masalah
yang berbeda.
• Pohon yang paling penting dari pertimbangan tersebut adalah :
➢ Lamanya waktu yang dihabiskan programmer dalam pengkodean
program sorting tertentu
➢ Jumlah waktu mesin yang diperlukan untuk menjalankan program
➢ Jumlah memory yang diperlukan untuk menjalankan program
• Berbagai metode penyortiran dianalisis dalam kasus seperti - kasus
terbaik, kasus terburuk atau kasus rata-rata.
• Sebagian besar metode pengurutan yang kami pertimbangkan memiliki
persyaratan yang berkisar dari 0(nlogn) hingga 0(n2).
• Suatu pengurutan tidak boleh dipilih hanya karena waktu pengurutannya
adalah 0(nlogn); hubungan ukuran file n dan faktor lain yang
mempengaruhi waktu penyortiran aktual harus dipertimbangkan
• Menentukan kebutuhan waktu teknik penyortiran adalah untuk benarbenar
menjalankan program dan mengukur efisiensinya.
• Setelah teknik pemilahan tertentu dipilih, kebutuhannya adalah membuat
program seefisien mungkin.
• Peningkatan apa pun dalam waktu penyortiran secara signifikan
memengaruhi efisiensi keseluruhan dan menghemat banyak waktu
komputer.
• Kendala ruang biasanya kurang penting dibandingkan pertimbangan
waktu.
Alasan untuk hal ini adalah, karena kebanyakan program penyortiran,
jumlah ruang yang dibutuhkan lebih dekat ke 0(n) daripada ke 0(n2 )
 Alasan kedua adalah, jika diperlukan lebih banyak ruang, hampir selalu
dapat ditemukan di penyimpanan tambahan.

Hal-hal untuk diingat

• Pengurutan yang ideal adalah pengurutan di tempat di mana algoritme
tidak menggunakan penyimpanan array tambahan, dan karena itu
dimungkinkan untuk mengurutkan daftar yang sangat besar tanpa perlu
mengalokasikan penyimpanan kerja tambahan.
• Algoritma pengurutan dikatakan stabil jika dua objek dengan kunci yang
sama muncul dalam urutan yang sama dalam output yang disortir seperti
yang muncul di input array yang tidak disortir.
• Beberapa algoritme pengurutan bersifat stabil seperti Insertion Sort, Merge
Sort, Bubble Sort, dll. Dan beberapa algoritme pengurutan tidak stabil,
seperti Heap Sort, Quick Sort, dll.
• Penyortiran dapat dilakukan dengan berbagai cara.
• Seiring berjalannya waktu, beberapa metode (atau algoritme) sedang
dikembangkan untuk mengurutkan data.
➢ Bubble sort, Seleksi sort, Quick sort, Merge sort, Insertion sort
adalah beberapa di antaranya teknik sortasi dibahas dalam bab ini.
• Sangat sulit untuk memilih algoritma pengurutan di atas yang lain. Dan
tidak ada algoritme pengurutan yang lebih baik dari yang lainnya dalam
segala situasi.

URUTAN GELEMBUNG
• Dalam pengurutan gelembung, setiap elemen dibandingkan dengan elemen
yang berdekatan.
• Kita mulai dengan elemen ke-0 dan membandingkannya dengan elemen
ke-1.
Jika ternyata lebih besar dari 1 elemen, maka mereka dipertukarkan.
 Dengan cara ini semua elemen dibandingkan (tidak termasuk yang
terakhir) dengan yang berikutnya elemen dan dipertukarkan jika
diperlukan
• Saat menyelesaikan iterasi pertama, elemen terbesar ditempatkan di posisi
terakhir. Demikian pula pada iterasi kedua, elemen terbesar kedua
ditempatkan

KOMPLEKSITAS WAKTU
• Kompleksitas waktu untuk bubble sort dihitung berdasarkan jumlah
perbandingan f(n) (atau jumlah loop)
• Di sini dua loop (loop luar dan loop dalam) beriterasi (atau berulang).
perbandingan.
• Perulangan dalam diulang satu kurang dari jumlah elemen di list (yaitu, n-
1 kali) dan diulang pada setiap iterasi dari luar lingkaran
f(n) = (n-1)+(n-2)+….+2+1
= n(n-1)=0(n2)
Kasus Terbaik
➢ menyortir array yang diurutkan dengan algoritme pengurutan
gelembung
 ➢ Dalam kasus terbaik, loop luar akan berakhir setelah satu iterasi,
yaitu melibatkan pelaksanaan satu lintasan yang membutuhkan
perbandingan n-1 f(n) = 0(n2) Kasus terburuk
➢ Misalkan sebuah array [5,4,3,2,1], kita perlu memindahkan elemen
pertama ke akhir array
• n-1 kali prosedur penukaran akan dipanggil f(n) = 0(n2)
• Rata-Rata Kasus
➢ Sulit untuk dianalisa dibanding kasus lainnya
➢ Masukan acak, begitu pada umumnya f(n) = O(n)
Kompleksitas Ruang
➢ O(n)

SOROT SELEKSI
• Temukan nilai terkecil (atau terbesar) dalam larik, tukarkan dengan nilai
paling kiri (atau paling kanan), lalu lupakan komponen paling kiri,
Lakukan ini berulang kali.
• Misalkan a[n] adalah larik linier dengan n elemen. Seleksi seleksi
berfungsi sebagai berikut:
➢ Langkah 1: Temukan lokasi lokasi elemen terkecil dalam daftar n
elemen a[0],a[1], [2], [3]..........a[n-1] lalu bertukar alokasi] dan a[0].
➢ Langkah 2: Temukan lokasi lokasi elemen terkecil di sub-daftar elemen
n-1 a[1], a[2], [3].............[n -1] dan kemudian bertukar alokasi] dan
a[1] sehingga a[0], a[1] diurutkan.
➢ Kemudian kita akan mendapatkan daftar yang diurutkan
a[0]<=a[2]<=a[3]……<=a[n-1]
Kompleksitas waktu
• Inner loop dieksekusi (n-1) kali saat i=0, (n-2) kali saat i=1 dan seterusnya
on:
• Kompleksitas waktu = (n-1) + (n-2) + (n-3)+...........+2+1 = O(n 2 )

Kompleksitas Ruang
• Karena tidak ada ruang tambahan selain n variabel yang diperlukan untuk
menyortir
• O(n)

Sortir Penyisipan
• Seperti menyortir tangan kartu remi dimulai dengan tangan kosong dan
kartu menghadap ke bawah meja.
• Ambil satu kartu sekaligus dari meja, dan masukkan ke posisi yang benar
di tangan kiri.
• Bandingkan dengan masing-masing kartu yang sudah ada di tangan, dari
kanan ke kiri
• Kartu yang dipegang di tangan kiri disortir.
• Misalkan sebuah array a[n] dengan n elemen.
• Jenis penyisipan berfungsi sebagai berikut:
➢ Pass 1: a[0] dengan sendirinya diurutkan dengan mudah.
➢ Pass 2: a[1] disisipkan sebelum atau sesudah a[0] sehingga a[0],
a[1] diurutkan.
➢ Pass 3: a[2] disisipkan ke tempatnya yang tepat di a[0],a[1] yaitu
sebelum a[0], antara a[0] dan a[1], atau setelah a[1] sehingga
a[0],a[1],a[2] diurutkan.
➢ pass N: a[n-1] dimasukkan ke tempat yang semestinya di
a[0],a[1],[2].........[n-2] sehingga a[0],a[1],a[2],……,a[n-1]
diurutkan dengan n elemen
Kompleksitas Waktu
• Kasus Terbaik:
➢ Jika array sudah disortir, maka Inner Loop wont mengeksekusi
sehingga hanya beberapa waktu yang konstan pernyataan akan
berjalan
➢ Jadi Kompleksitas waktu= O(n) Kasus terburuk:
➢ Elemen array dalam urutan terurut terbalik
➢ Kompleksitas waktu=O(n 2 ) Kompleksitas Ruang
➢ Karena tidak ada ruang tambahan selain n variabel yang diperlukan
untuk menyortir
➢ Kompleksitas Ruang = O(n)

Membagi dan menaklukkan algoritma

• Algoritma pengurutan yang telah kita lihat sejauh ini memiliki waktu
operasi terburuk O(n 2 )
• Ketika ukuran larik masukan besar, algoritma ini dapat memakan waktu
lama untuk dijalankan.
• Sekarang kita akan membahas dua algoritma sorting yang running timenya
lebih baik
➢ Menggabungkan Sortir
➢ Urutkan Cepat
Memecah dan menaklukkan
• Divide-and-conquer, memecah masalah menjadi sub-sub masalah yang
mirip dengan masalah awal, menyelesaikan sub masalah secara rekursif,
dan terakhir menggabungkan solusi dari sub masalah untuk menyelesaikan
masalah awal.
• Pikirkan algoritma bagi-dan-taklukkan yang memiliki tiga bagian:
➢ Membagi masalah menjadi sejumlah submasalah yang merupakan
contoh lebih kecil dari masalah yang sama
➢ Taklukkan submasalah dengan menyelesaikannya secara rekursif. Jika
mereka kecil cukup, selesaikan submasalah sebagai kasus dasar.
➢ Gabungkan solusi dari submasalah ke dalam solusi untuk aslinya
masalah.

Gabungkan Sortir
• Merge sort adalah teknik sortasi yang didasarkan pada teknik Divide and
Conquer.
• Merge sort pertama-tama membagi array menjadi dua bagian yang sama
dan kemudian menggabungkannya dengan cara diurutkan.
• Dengan kompleksitas waktu kasus terburuk adalah O(n log n), ini adalah
salah satu yang paling banyak algoritma dihormati.
• Karena kita menggunakan devide-and-conquer untuk menyortir, kita perlu
memutuskan apa yang akan menjadi sub-masalah kita.
➢ Masalah Penuh: Mengurutkan seluruh Array
➢ Sub Soal: Mengurutkan sub larik
• Mari kita asumsikan array[p..r] menunjukkan subarray dari array ini.
• Untuk larik n elemen, kita katakan masalah aslinya adalah mengurutkan
array[0..n-1]

• Berikut cara penggabungan menggunakan pembagian dan penaklukkan

1. Bagilah dengan mencari bilangan q pada posisi tengah antara p dan r.
Lakukan langkah ini dengan cara yang sama seperti kita menemukan
titik tengah dalam pencarian biner: tambahkan p dan r, bagi dengan 2,
dan bulatkan ke bawah.
2. Taklukkan dengan menyortir subarray secara rekursif di
masingmasing dari dua sub masalah yang dibuat oleh langkah
pembagian.
Yaitu, mengurutkan array subarray[p..q] secara rekursif dan
mengurutkan array subarray[q+1..r] secara rekursif.
 3. Gabungkan dengan menggabungkan dua subarray yang telah
diurutkan kembali menjadi satu urutan subarray array[p..r]
4. Mari kita mulai dengan penahan array
[14,7,3,12,9,11,6,2]
5. Kita dapat mengatakan bahwa array[0..7] di mana p=0 dan r=7
6. Pada langkah pembagian kita menghitung q=3 array[0..3][14,7,3,12]
Langkah taklukkan membuat kita mengurutkan keduanya kereta
bawah tanah kita kembali dari langkah penaklukan, masingmasing
dari dua subarray diurutkan
i.e larik[0..3] =
[3,7,12,14]
7. Terakhir, langkah penggabungan menggabungkan dua subarray
terurut pada paruh pertama dan paruh kedua, menghasilkan larik
terurut akhir [2, 3, 6,7,9, 11, 12,14]

Bagaimana array subarray[0..3] diurutkan?

• Ini memiliki lebih dari dua elemen jadi ini bukan kasus dasar.
• Jadi dengan p=0 dan r=3, hitung q=1, urutkan array[0..1] dan array[2..3]
secara rekursif, menghasilkan array[0..3] berisi [7,14,3 ,12] dan
menggabungkan setengah kepalan dengan setengah kedua, menghasilkan
[3,7,12,14]

Bagaimana array subarray[0..1] diurutkan?

• Dengan p=0 dan r=1, hitung q=0, urutkan array[0..0] ([14]) dan array[1..1]
([7] secara rekursif), menghasilkan array[0.. 1] masih berisi [14, 7], dan
menggabungkan paruh pertama dengan paruh kedua, menghasilkan [7,
14].
Analisis Sortir gabungan
• Kita dapat melihat urutan gabungan seperti membuat pohon panggilan, di
mana setiap level rekursi adalah level di dalam pohon.
• Karena setiap kali jumlah elemen dibagi dua, pohon tersebut adalah pohon
biner seimbang.
• Tinggi pohon seperti itu cenderung log n
• Memecah dan menaklukkan
• Rekursif
• Stabil
• Tidak di tempat
• 0(n) kompleksitas ruang
• 0(nlogn) kompleksitas waktu
• Waktu untuk menggabungkan urutan n angka sama dengan waktu untuk
melakukan dua penggabungan rekursif ukuran n/2 ditambah waktu untuk
menggabungkan, yang linier.
• Kita dapat menyatakan jumlah operasi yang terlibat menggunakan yang
berikut ini hubungan kekambuhan
T(1)=1
T(n) =2T(n/2)+n
• Lebih jauh ke bawah menggunakan logika yang sama
T(n/2)=2T(n/2)+n/2
• Melanjutkan dengan cara ini, kita bisa menulis
 T(n)=nT(1)+nlogn
=n+nlogn
T(n)=0(nlogn)
• Meskipun waktu pengoperasian merge sort sangat menarik, ini tidak
disukai untuk menyortir data di memori utama.
• Masalah utama muncul ketika menggunakan memori ekstra linier karena
kita perlu menyalin larik asli menjadi dua larik berukuran setengah dan
pekerjaan tambahan dihabiskan untuk menyalin ke larik sementara dan
sebaliknya
• Hal ini dapat sangat memperlambat waktu penyortiran
• Namun jenis gabungan dapat bekerja dengan baik dengan daftar tertaut
karena tidak memerlukan ruang tambahan. Karena kita hanya perlu
mengubah tautan penunjuk daripada menggeser elemen

Sortir Cepat
• Penyortiran cepat adalah salah satu teknik penyortiran yang paling
populer.
• Seperti namanya, pengurutan cepat adalah algoritma pengurutan tercepat
yang diketahui dalam praktiknya.
• Ini memiliki kinerja waktu rata-rata terbaik.
• Ia bekerja dengan mempartisi array yang akan diurutkan dan setiap partisi
pada gilirannya diurutkan secara rekursif. Karenanya juga disebut
semacam pertukaran partisi.
• Pada partisi salah satu elemen array dipilih sebagai elemen pivot
• Pilih elemen pivot=a[n-1]. Misalkan elemen-elemen dari array a dipartisi
sehingga pivot ditempatkan pada posisi I dan berlaku kondisi berikut:

➢ Setiap elemen pada posisi 0 sampai i-1 kurang dari atau sama
dengan poros atau
➢ Masing-masing elemen pada posisi i+1 sampai n-1 lebih besar dari
sama dengan kunci
 ➢ Pivot tetap pada posisi ke-i ketika array telah diurutkan secara
lengkap. Terus mengulangi proses ini pada akhirnya akan
mempersingkat array

Algoritma
• Memilih poros
Untuk mempartisi daftar, pertama-tama kita memilih elemen pivot
• Partisi
➢ Kemudian kita mempartisi elemen sehingga semua elemen
dengan nilai kurang dari pivot ditempatkan di sisi kiri dan nilai
yang lebih tinggi di sebelah kanan
➢ Periksa apakah elemen saat ini kurang dari pivot. Jika lebih
kecil ganti dengan elemen saat ini dan pindahkan dinding ke
atas posisi
jika tidak, pindahkan elemen pivot ke elemen saat ini dan
sebaliknya
• Ulangi langkah partisi yang sama kecuali semua elemen disortir
Analisis Sortir Cepat
• Kasus terbaik
➢ Analisis kasus terbaik mengasumsikan bahwa pivot selalu berada
di tengah
➢ Untuk menyederhanakan perhitungan, kita mengasumsikan bahwa
kedua sublist masing-masing persis setengah dari ukuran aslinya
T(N)=T(N/2)+T(N /2)....+1 mengarah ke T(N)= 0(nlogn) Rata-
rata kasus
➢ T(N)=O(nlogn) Kasus terburuk
➢ Ketika kita memilih minimum atau maksimum sebagai pivot maka
kita harus melalui setiap elemen demikian
➢ T(N0=0(n2)

Tumpukan
• Tumpukan didefinisikan sebagai pohon biner yang hampir lengkap o node
n sedemikian rupa sehingga nilai setiap node kurang dari atau sama
dengan nilai ayah ATAU lebih besar dari atau sama dengan nilai ayah.
• Descending heap adalah pohon biner yang hampir lengkap di mana
nilainya setiap simpul lebih kecil atau sama dengan nilai ayahnya
• Ascending heap adalah pohon biner yang hampir lengkap di mana nilainya
rach node adalah arestar atau sama dengan nilai ayahnya
• Heap adalah kasus khusus dari struktur data pohon biner seimbang di
mana kunci root-node dibandingkan dengan anak-anaknya dan diatur
sesuai dengan itu.
• Jika a memiliki simpul anak ẞ maka - •Kunci( a ) >= kunci( B )
• Karena nilai parent lebih besar dari child, properti ini menghasilkan MAX
heap. Berdasarkan kriteria ini, tumpukan dapat terdiri dari dua jenis
➢ Min-heap
➢ Max-heap
 • Min heap
➢ Di mana nilai simpul akar kurang dari atau sama dengan salah satu
anaknya
➢ Untuk masukan 35 33 42 10 14 19 27 44 26 31

• Max heap
➢ di mana nilai simpul akar lebih besar atau sama dengan salah satu
anaknya.
➢ Untuk masukan 35 33 42 10 14 19 27 44 26 31

Algoritma Max Heap Construction

• Langkah 1 - Buat node baru di akhir heap.
• Langkah 2 - Tetapkan nilai baru ke node.
• Langkah 3 - Bandingkan nilai simpul anak ini dengan induknya.
• Langkah 4 - Jika nilai induk lebih kecil dari anak, maka tukarkan.
• Langkah 5 - Ulangi langkah 3 & 4 hingga properti Heap berlaku.

Algoritma Penghapusan Tumpukan Maks

Langkah 1 - Hapus node root.
 • Langkah 2 - Pindahkan elemen terakhir dari level terakhir ke root.
• Langkah 3 - Bandingkan nilai simpul anak ini dengan induknya.
• Langkah 4 - Jika nilai induk lebih kecil dari anak, maka tukarkan.
• Langkah 5 - Ulangi langkah 3 & 4 hingga properti Heap berlaku.

Analisis Sortir Tumpukan

• Kompleksitas kasus terburuk dari pengurutan heap adalah O(nlogn), oleh
karena itu, pengurutan heap lebih unggul daripada pengurutan cepat dalam
kasus terburuk
• Pengurutan heap sangat tidak efisien untuk array kecil karena overhead
pembuatan dan komputasi heap awal.
• Persyaratan ruang untuk pengurutan hap hanya satu record tambahan
untuk menampung nilai sementara.

Sortir Radix
• Gagasan di balik penyortiran radix sedikit lebih kompleks daripada
gagasan ember menyortir.
• Algoritma:
➢ Ambil digit terkecil dari setiap elemen yang tidak disortir
Himpunan
➢ Lakukan pengurutan yang stabil berdasarkan kunci tersebut
➢ Ulangi proses secara berurutan dengan setiap digit yang lebih
signifikan
• Misal kita ingin mengurutkan list
849,770,67,347,201,618,66,495,13,45
• Mengurutkan berdasarkan digit paling signifikan (yaitu digit satuan)
770.201,13.495,45,66,67.347.618.849
• Stabilitas terjaga. Sekarang urutkan berdasarkan digit puluhan yang lebih
signifikan,
 210,13,618,45,347,849,66,67,770,495
• Kita sekarang menganggap angka ratusan sebagai nol
12,45,66,67,201,347,495,618,770,849