MAKALAH

SORTING

D
I
S
U
S
U
N

OLEH:

NADIA FEBIANTI
NIM :2022903430027

Dosen Pembimbing : Indrawati, SST.MT

JURUSAN TEKNOLOGI INFORMASI DAN KOMPUTER

PRODI TEKNOLOGI REKAYASA KOMPUTER DAN JARINGAN
POLITEKNIK NEGERI LHOKSEUMAWE
TAHUN 2022/2023
 KATA PENGANTAR

Alhamdulillah kami panjatkan puji syukur kami ke hadirat Allah SWT. Sehingga
penulis telah menyelesaikan Makalah program sorting ini dengan tepat waktu.

Salah satu tujuan penulis dalam menulis Makalah program sorting ini adalah
sebagai dokumentasi dan juga bentuk evaluasi kegiatan program sorting. Makalah
yang penulis buat ini berdasarkan data-data yang valid yang telah dikumpulkan
dalam berbagai metode.

Penulis menyadari atas ketidaksempurnaan penyusunan Makalah program sorting

ini. namun penulis tetap berharap laporan ini akan memberikan manfaat bagi para
pembaca. Demi kemajuan penulis, penulis juga mengharapkan adanya masukan
berupa kritik atau saran yang berguna. Terima kasih.

i
 DAFTAR ISI
KATA PENGANTAR.......................................................................................................i
BAB I................................................................................................................................1
PENDAHULUAN.............................................................................................................1
A. Latar Belakang.....................................................................................................1
B. Rumusan Masalah................................................................................................1
C. Tujuan Masalah...................................................................................................1
BAB II...............................................................................................................................3
PEMBAHASAN...............................................................................................................3
A. Pengertian Sorting................................................................................................3
1.1 Insertion Sort................................................................................................3
1.2 Seletion Sort..................................................................................................5
1.3 Merge Sort....................................................................................................5
1.4 Quick Sort.....................................................................................................7
1.5 Bubble Sort...................................................................................................9
1.6 Counting Sort..............................................................................................10
1.7 Heap Sort....................................................................................................11
1.8 Shell Short...................................................................................................12
1.9 Radix Sort...................................................................................................13
1.1.0 Tree Sort.................................................................................................14
B. Searching............................................................................................................15
2.1 Linear Searching........................................................................................15
2.2 Binary Searching..............................................................................................16
C. Source Code........................................................................................................17
3.1 Heap Sort..........................................................................................................17
3.2 Shell Short...................................................................................................19
3.3 Quick Short.................................................................................................20
3.4 Merge Sort..................................................................................................22
3.5 Radix Sort...................................................................................................24
3.6 Tree Sort.....................................................................................................27
BAB III...........................................................................................................................29
PRAKTIKUM................................................................................................................29

ii
 A. Program dan Output..........................................................................................29
Bubble Sort :...........................................................................................................29
Insertion Sort :.......................................................................................................32
Selection Sort :........................................................................................................35
Counting Sort :.......................................................................................................37
Merge Sort :............................................................................................................39
BAB IV............................................................................................................................43
PENUTUP.......................................................................................................................43
A. Kesimpulan.........................................................................................................43
B. Saran...................................................................................................................43
DAFTAR PUSTAKA.....................................................................................................44

iii
 BAB I
PENDAHULUAN

A. Latar Belakang
Algoritma merupakan kumpulan perintah yang memiliki daya guna yang
sangat besar bagi masyarakat. Algoritma biasanya digunakan sebagai kumpulan
perintah untuk menyelesaikan suatu masalah. Algoritma ini memiliki aplikasi
yang bermacam-macam dalam setiap masalah yang ada. Contohnya saja adalah
algoritma cara menyelesaikan suatu aritmatika yang rumit, algoritma untuk
menghitung luas penampang dari suatu kabel, atau bahkan untuk menghitung
bayaran parkir di setiap mal. Salah satu aplikasi bentuk pemrograman ini adalah
dalam bahasa permrograman yang disebut bahasa C. Dimana bahasa C ini
memiliki suatu aturan-aturan tertentu yang sangat penting sehingga dalam
penggunaanya kita harus memperhatikan cara menggunakan aturan tersebut. Salah
satu cara penggunaannya adalah dengan array.

B. Rumusan Masalah
Timbulnya masalah akibat sulitnya pekerjaan yang dilaksanakan secara
manual pada masyarakat menyebabkan adanya pemborosan waktu, tenaga, dan
pikiran. Pemborosan –pemborosan ini menyebabkan kerugian pada masyarakat itu
sendiri bahkan secara akumulatif jika kerugian pada tiap individu dijumlahkan,
maka dampaknya akan menjadi kerugian sebuah negara, bahkan secara lebih luas
dapat berdampak pada kerugian global. Sebagai alternatif, suatu sistem algoritma
mengatasi permasalahan tersebut dengan searching dan sorting array.

C. Tujuan Masalah
Makalah ini disusun untuk memaparkan tentang pengertian sorting dan
searching array dalam aplikasi di dunia kerja. Dengan membaca makalah ini,
pembaca akan mengetahui lebih dalam mengenai membuat algoritma dari
searching dan sorting array yang bisa dijadikan sebagai referensi dalam
pembuatan algoritma. Selain itu, pembaca juga akan mengetahui manfaat dari
searching dan sorting array dalam aplikasinya didunia kerja.

2
 BAB II
PEMBAHASAN

A. Pengertian Sorting
1.1 Insertion Sort
  Salah satu algoritma sorting yang paling sederhana adalah insertion sort.
Ide dari algoritma ini dapat dianalogikan seperti mengurutkan kartu. Penjelasan
berikut ini menerangkan bagaimana algoritma insertion sort bekerja dalam
pengurutan kartu. Anggaplah anda ingin mengurutkan satu set kartu dari kartu
yang bernilai paling kecil hingga yang paling besar. Seluruh kartu diletakkan pada
meja, sebutlah meja ini sebagai meja pertama, disusun dari kiri ke kanan dan atas
ke bawah. Kemudian kita mempunyai meja yang lain, meja kedua, dimana kartu
yang diurutkan akan diletakkan. Ambil kartu pertama yang terletak pada pojok
kiri atas meja pertama dan letakkan pada meja kedua. Ambil kartu kedua dari
meja pertama, bandingkan dengan kartu yang berada pada meja kedua, kemudian
letakkan pada urutan yang sesuai setelah perbandingan. Proses tersebut akan
berlangsung hingga seluruh kartu pada meja pertama telah diletakkan berurutan
pada meja kedua. Algoritma insertion sort pada dasarnya memilah data yang akan
diurutkan menjadi dua bagian, yang belum diurutkan (meja pertama) dan yang
sudah diurutkan (meja kedua). Elemen pertama diambil dari bagian array yang
belum diurutkan dan kemudian diletakkan sesuai posisinya pada bagian lain dari
array yang telah diurutkan. Langkah ini dilakukan secara berulang hingga tidak
ada lagi elemen yang tersisa pada bagian array yang belum diurutkan.

Algoritmanya :

void insertionSort(Object array[], int startIdx, int endIdx) {

for (int i = startIdx; i < endIdx; i++) {
int k = i;
for (int j = i + 1; j < endIdx; j++) {
if(((Comparable) array[k]).compareTo(array[j])>0) {

3
k = j;
}
}
swap(array[i],array[k]);
}
}

4
1.2 Seletion Sort

Jika anda diminta untuk membuat algoritma sorting tersendiri, anda mungkin

akan menemukan sebuah algoritma yang mirip dengan selection
sort. Layaknya insertion sort, algoritma ini sangat rapat dan mudah untuk
diimplementasikan. Mari kita kembali menelusuri bagaimana algoritma ini
berfungsi terhadap satu paket kartu. Asumsikan bahwa kartu tersebut akan
diurutkan secara ascending. Pada awalnya, kartu tersebut akan disusun secara
linier pada sebuah meja dari kiri ke kanan, dan dari atas ke bawah. Pilih nilai kartu
yang paling rendah, kemudian tukarkan posisi kartu ini dengan kartu yang terletak
pada pojok kiri atas meja. Lalu cari kartu dengan nilai paling rendah diantara sisa
kartu yang tersedia. Tukarkan kartu yang baru saja terpilih dengan kartu pada
posisi kedua. Ulangi langkah – langkah tersebut hingga posisi kedua sebelum
posisi terakhir dibandingkan dan dapat digeser dengan kartu yang bernilai lebih
rendah.
Ide utama dari algoritma selection sort adalah memilih elemen dengan nilai paling
rendah dan menukar elemen yang terpilih dengan elemen ke-i. Nilai dari i dimulai
dari 1 ke n, dimana n adalah jumlah total elemen dikurangi 1.

Algoritmanya :

void selectionSort(Object array[], int startIdx, int endIdx) {

int min;
for (int i = startIdx; i < endIdx; i++) {
min = i;
for (int j = i + 1; j < endIdx; j++) {
if ((( Comparable ) array [min] ) . compareTo (array[j])>0) {
min = j;
}
}
swap(array[min], array[i]);
}
}

1.3 Merge Sort

5
 Beberapa algoritma mengimplementasikan konsep rekursi untuk
menyelesaikan permasalahan. Permasalahan utama kemudian dipecah menjadi
sub-masalah, kemudian solusi dari sub-masalah akan membimbing menuju solusi
permasalahan utama.

Pada setiap tingkatan rekursi, pola tersebut terdiri atas 3 langkah.

1. Divide
Memilah masalah menjadi sub masalah.

2. Conquer
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah tersebut cukup
ringkas dan sederhana, pendekatan penyelesaian secara langsung akan lebih
efektif.

3. Kombinasi
Mengkombinasikan solusi dari sub-masalah, yang akan membimbing menuju
penyelesaian atas permasalahan utama.

Seperti yang telah dijelaskan sebelumnya, Merge sort menggunakan pola divide

and conquer. Dengan hal ini deskripsi dari algoritma dirumuskan
dalam 3 langkah berpola divide-and-conquer. Berikut menjelaskan langkah kerja
dari Merge sort.

1. Divide
Memilah elemen – elemen dari rangkaian data menjadi dua bagian.

2. Conquer
Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif.

3. Kombinasi
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan
rangkaian data berurutan.

6
 Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana
bagian yang akan diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu
elemen tersebut menandakan bahwa bagian tersebut telah terurut sesuai rangkaian.

Algoritmanya :

void mergeSort(Object array[], int startIdx, int endIdx) {

if (array.length != 1) {
//Membagi rangkaian data, rightArr dan leftArr
mergeSort(leftArr, startIdx, midIdx);
mergeSort(rightArr, midIdx+1, endIdx);
combine(leftArr, rightArr);
}
}

1.4 Quick Sort

Quicksort ditemukan oleh C.A.R Hoare. Seperti pada merge sort, algoritma ini
juga berdasar pada pola divide-and-conquer. Berbeda dengan merge sort,
algoritma ini hanya mengikuti langkah – langkah sebagai berikut:

7
1. Divide
Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r]
dimana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q] dan
setiap elemen pada A[q+1…r] adalah lebih besar atau sama dengan elemen pada
A[q]. A[q] disebut sebagai elemen pivot. Perhitungan pada elemen q merupakan
salah satu bagian dari prosedur pemisahan.

2. Conquer
Mengurutkan elemen pada sub-rangkaian secara rekursif Pada
algoritma quicksort, langkah “kombinasi” tidak di lakukan karena telah terjadi
pengurutan elemen – elemen pada sub-array
Algoritmanya :
void quickSort(Object array[], int leftIdx, int rightIdx) {
int pivotIdx;
/* Kondisi Terminasi */
if (rightIdx > leftIdx) {
pivotIdx = partition(array, leftIdx, rightIdx);
quickSort(array, leftIdx, pivotIdx-1);
quickSort(array, pivotIdx+1, rightIdx);
}
}

8
1.5 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. Jikaternyata urutannya
tidak sesuai dengan “pesanan”,maka dilakukan pertukaran (swap).

9
1.6 Counting Sort
Counting sort adalah suatu metode pengurutan dimana dalam proses
pengurutannya yaitu dengan menentukan posisi elemen suatu nilai. Jadi pada
prosesnya dibutuhkan suatu rentang nilai yang sudah diketahui dan pada
prosesnya menentukan jumlah nilai yang nilainya lebih kecil dari elemen lain agar
dapat menentukan posisi nilai tersebut. Proses Counting Sort ini terbilang efisien
dan efektif serta prosesnya tidak memakan waktu lama.

#include <stdio.h>

int main()
{
int L[20], temp, i, j, n=6, idx;
printf("Masukkan 6 Element : \n");

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

{
printf("Masukkan Bilangan : "); scanf("%d", &L[i]);
}

printf("\nSebelum di sorting : ");

10
 for(i=0; i<n; i++)
{
printf("%d ", L[i]);
}

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

{
idx=i;
for(j=i+1; j<n; j++)
{
if(L[j]<L[idx])
{
idx=j;
}
}
temp=L[i];
L[i]=L[idx];
L[idx]=temp;
}

printf("\nSetelah Sorting : ");

for(i=0; i<n; i++)
{
printf("%d ", L[i]);
}
printf("\n");
return 0;
}

1.7 Heap Sort

Heap Sort adalah sebuah algoritma pengurutan yang paling lambat dari
algoritma yang memiliki kompleksitas O(n log n). Tetapi tidak seperti algoritma
Merge Sort dan Quick Sort, algoritma Heap Sort tidak memerlukan rekursif yang
besar atau menggunakan banyak tabel (array). Oleh karena itu, Heap Sort adalah
pilihan yang baik untuk sebuah kumpulan data yang besar.

Algoritma ini bekerja dengan menentukan elemen terbesar (atau terkecil) dari
sebuah daftar elemen, dan diletakkan pada akhir (atau awal) dari daftar tersebut.

11
 Heap sort menyelesaikan sebuah pengurutan menggunakan struktur data yang
disebut heap.

Algoritma ini dimulai dengan membangun sebuah array heap dengan membangun
tumpukan dari kumpulan data, lalu memindahkan data terbesar ke bagian
belakang dari sebuah tabel hasil. Setelah itu, array heap dibangun kembali,
kemudian mengambil elemen terbesar untuk diletakkan di sebelah item yang telah
dipindahkan tadi. Hal ini diulang sampai array heap habis. Jadi secara umum,
algoritma ini memerlukan dua buah tabel; satu tabel untuk menyimpan heap, dan
satu tabel lainnya untuk menyimpan hasil. Walaupun lebih lambat dari Merge Sort
atau Quick Sort, algoritma ini cocok untuk digunakan pada data yang berukuran
besar.

1.8 Shell Short

Metode pertambahan menurun (diminishing increment). Metode ini
dikembangkan oleh Donald L. Shell pada tahun 1959, sehingga sering disebut
dengan Metode Shell Sort. Metode ini mengurutkan data dengan cara
membandingkan suatu data dengan data lain yang memiliki jarak tertentu,
kemudian dilakukan penukaran bila diperlukan.

Shell Sort merupakan salah satu algoritma pengurutan yang lebih handal
dibandingkan Selection Sort dan Bubble Sort. Kehandalannya yaitu: “Membagi
deret data menjadi dua bagian. Masing-masing bagian diurutkan menggunakan
Bubble Sort. Tidak menggunakan iterasi melainkan increment. Perulangan
diakukan sesuai nilai increment”.

Pertama menentukan jarak mula-mula dari data yang akan dibandingkan,

yaitu N/2. Data pertama dibandingkan dengan data dengan jarak N/2. Apabila data
pertama lebih besar dari data ke N/2 tersebut maka kedua data tersebut ditukar.
Kemudian data kedua dibandingkan dengan jarak yang sama yaitu N/2. Demikian
seterusnya sampai seluruh data dibandingkan sehingga semua data ke-j selalu
lebih kecil daripada data ke-(j + N/2).

12
 Pada proses berikutnya, digunakan jarak (N/2) / 2 atau N/4. Data pertama
dibandingkan dengan data dengan jarak N/4. Apabila data pertama lebih besar
dari data ke N/4 tersebut maka kedua data tersebut ditukar. Kemudian data kedua
dibandingkan dengan jarak yang sama yaitu N/4. Demikianlah seterusnya hingga
seluruh data dibandingkan sehingga semua data ke-j lebih kecil dari data ke-(j +
N/4).

Pada proses berikutnya, digunakan jarak (N/4) / 2 atau N/8. Demikian

seterusnya sampai jarak yang digunakan adalah 1.

Algoritma metode Shell dapat dituliskan sebagai berikut :

1.             Jarak = N
2.             Selama (Jarak > 1) kerjakan baris 3 sampai dengan 9
3.             Jarak = Jarak / 2. Sudah = false
4.             Kerjakan baris 4 sampai dengan 8 selama Sudah = false
5.             Sudah = true
6.             j = 0
7.             Selama (j < N – Jarak) kerjakan baris 8 dan 9
8.             Jika (Data[j] > Data[j + Jarak] maka tukar Data[j], Data[j + Jarak], Sudah = true
9.             j = j + 1

1.9 Radix Sort

Radix sort adalah algoritma non-comparation sort atau pengurutan tanpa
perbandingan . metode ini mengklarifikisi sebuah data sesuai dengan kategori
urutan tertentu. Dan setiap kategori diurutkan lagi dan seterusnya sesuai dengan
kebutuhan. Kemudian bagian2 dari kategori tersebut akan digabungkan kembali.

Catatan : data yang diurutkan pertama kali yaitu berupa input nilai2 yang
dimasukkan pertama kali berdasarkan radix pertamanya, lalu diteruskan atau
diurutkan lagi berdasarkan radix keduanya, dst. Pada system decimal radix adalah

13
 digit dalam angka decimal. Missal : angka 354 mempunyai 3 digit yaitu 3, 5 dan
4.

1.1.0 Tree Sort

Tree sort adalah teknik mengurutkan data dengan menggunakan struktur
data tree. Kelebihan: Data langsung urut begitu dimasukkan, efektif untuk jumlah
data yang kecil. Kekurangan: Tidak efektif untuk jumlah data yang besar.

14
B. Searching
2.1 Linear Searching
Algoritma pencarian secara linear adalah algoritma untuk mencari sebuah
nilai pada table sambarang dengan cara melakukan pass atau transversal.
Transversal dari awal sampai akhir table. Ada dua macam cara pencarian pada
table. Algoritma mempunyai dua jenis metode yaitu dengan Boolean dan tanpa
Boolean.

void SeqSearch1 (int T[], int Nmax,

int value, int *idx){/*kamus lokal*/
int i;/*Algoritma*/
i = 1;
while ((i<Nmax) && (T[i] != value)){
i = i + 1;
}
if (T[i]==value){
*idx = i;
}
else{
*idx = 0;
}
}
Algoritma di atas melakukan pengulangan sampai i sama dengan Nmax (ukuran
tabel) atau harga value dalam tabel sudah ditemukan.    Kemudian harga i di-
assign ke dalam variable idx. Elemen terakhir diperiksa secara khusus.

void SeqSearch2 (int T[],int Nmax,

int value, int *idx){
int i;
boolean found;/*algoritma*/
i = 1;
found = false;
while ((i<=Nmax) && (!found)){
if (T[i] == value){

15
 found = true;
}
else{
i = i + 1;
}
}
if (found){
*idx = i;
}
else{
*idx = 0;
}

2.2 Binary Searching

Algoritma pencairan secara linear melakukan pengulangan sebanyak 1 kali
untuk kasus terbaik (value sama dengan elemen pertama dalam tabel) dan Nmax
kali untuk kasus terburuk.

Sehingga algoritma ini mempunyai kompleksitas algoritma O(n).

Implementasi algoritma pencarian biner dalam bahasa C adalah sebagai berikut.

void BinSearch (int T[],int Nmax, int value, int* idx)

int i,j,mid;
boolean found;$
/*algoritma*/
found = false;
i = 1;
j = Nmax;
while ((!found) && (i<=j)){
mid = (i+j) div 2;
if (T[mid] == value){
found = true;
}

16
 else{
if (T[mid]<value)
{
i = mid + 1;
}
else{
j = mid – 1;
}
}
}
if (found){
*idx = mid;
}
else{
*idx = 0;
}
}

Algoritma pencarian biner adalah algoritma untuk mencari sebuah nilai pada tabel
teurut dengan cara menghilangkan setengah data pada setiap langkah. Algoritma
ini mencari nilai yang dicari dengan tiga langkah yaitu :

- Mencari nilai tengah dari tabel (median)

- Melakukan perbandingan nilai tengah dengan nilai yang dicari
untuk   menentukan apakah nilai yang dicari ada pada sebelum atau setelah nilai
tengah
- Mencari setengah sisanya dengan cara yang sama.

C. Source Code
3.1 Heap Sort
#include<stdio.h>
#include <windows.h>

17
void makeheap(int a[], int n)
{
 int i, temp, k, j;
 for (i = 1; i<n; i++)

 {
  temp = a[i];
  k = (i - 1) / 2;
  j = i;
  while (j>0 && a[k] < temp)
 {
   a[j] = a[k];
   j = k;
   k = (j - 1) / 2;
 }
  a[j] = temp;
 }
}
void disp(int a[], int n)
{
 int i;
 for (i = 0; i < n; i++)
 {
  printf("%d,", a[i]);
 }
 printf("\b");
 printf(" ");
}
void sortheap(int a[], int n)
{
 int temp, i, j;
 for (i = n - 1; i >= 1; i--)
 {
  temp = a[i];
  a[i] = a[0];

18
   a[0] = temp;
  makeheap(a, i);
  printf("\n\t-->");
  disp(a, n);
 }
}
void main()

{
 int a[100], n, i;
 system("cls");
 printf("\n\tJumlah Element : ");
 scanf("%d", &n);
  system("cls");
 printf("\n\tElemen Array \n");
 for (i = 0; i < n; i++)
 {
  printf("\tElement %d := ", i + 1);
  scanf("%d", &a[i]);
 }
 makeheap(a, n);
 printf("\n\tHeap Created := ");
 disp(a, n);
 sortheap(a, n);
 printf("\n\n\tSorted Elements := ");
 disp(a, n);
 getch();
}

3.2 Shell Short

#include "stdio.h"

int main()
{

19
     int L[20],temp,i,j,n=6,m;
    printf("pengurutan berdasarkan Shell sort \nmasukkan %d elements: \n",n);
    for(i=0;i<n;i++){
        scanf("%d",&L[i]);}

    printf("\nsebelum sorting: ");

    for(i=0;i<n;i++){printf("%d ",L[i]);}

    for(m = n/2;m>0;m/=2){

    /*6 7 2 1 ===> 2 7 6 1, 2 1 6 7 // 1 2 6 7, 1 2 6 7, 1 2 6 7*/
        for(j=m;j<n;j++){
            for(i=j-m;i>=0;i-=m){
                if(L[i+m]>=L[i]) break;
                else{
                    temp = L[i];
                    L[i] = L[i+m];
                    L[i+m] = temp;
                }
            }
        }
    }

    printf("\nsetelah sorting: ");

    for(i=0;i<n;i++){printf("%d ",L[i]);}
    printf("\n");
}

3.3 Quick Short

#include <stdio.h>
#include <stdlib.h>

void quickSort (int a[], int lo, int hi){

20
//  lo adalah index bawah, hi adalah index atas
//  dari bagian array yang akan di urutkan
    int i=lo, j=hi, h;
    int pivot=a[lo];

//  pembagian
    do{
        while (a[i]<pivot) i++;
        while (a[j]>pivot) j--;
        if (i<=j)
        {
            h=a[i]; a[i]=a[j]; a[j]=h;//tukar
            i++; j--;
        }
    } while (i<=j);

//  pengurutan
    if (lo<j) quickSort(a, lo, j);
    if (i<hi) quickSort(a, i, hi);
}

main(){
    int tabInt[10]={24,17,18,15,22,26, 13, 21, 16, 28};
    int i,n=10;

    for(i=0;i<n;i++){
        printf("%d ",tabInt[i]);
   }
    printf("\n");
    quickSort(tabInt,0,n-1);

    for(i=0;i<n;i++){
        printf("%d ",tabInt[i]);
    }
}

21
3.4 Merge Sort
#include <stdio.h>
#define MAX 10
int Data[MAX];
int temp[MAX];

// Prosedur merge sort

void merge(int Data[], int temp[], int kiri, int tengah, int kanan)
{
            int i, left_end, num_elements, tmp_pos;
            left_end = tengah - 1;
            tmp_pos = kiri;
            num_elements = kanan - kiri + 1;

            while ((kiri <= left_end) && (tengah <= kanan))

            {
                        if (Data[kiri] <= Data[tengah])
                        {
                                    temp[tmp_pos] = Data[kiri];
                                    tmp_pos = tmp_pos + 1;
                                    kiri = kiri +1;
                        }
                        else
                        {
                        temp[tmp_pos] = Data[tengah];
                        tmp_pos = tmp_pos + 1;
                        tengah = tengah + 1;
                        }
            }
            while (kiri <= left_end)
            {
                        temp[tmp_pos] = Data[kiri];
                        kiri = kiri + 1;

22
                        tmp_pos = tmp_pos + 1;
            }
            while (tengah <= kanan)
            {
                        temp[tmp_pos] = Data[tengah];
                        tengah = tengah + 1;
                        tmp_pos = tmp_pos + 1;
            }

            for (i=0; i <= num_elements; i++)

            {
                        Data[kanan] = temp[kanan];
                        kanan = kanan - 1;
            }
}
// Prosedur membuat kumpulan data

void m_sort(int Data[], int temp[], int kiri, int kanan)

{
            int tengah;
            if (kanan > kiri)
            {
                        tengah = (kanan + kiri) / 2;
                        m_sort(Data, temp, kiri, tengah);
                        m_sort(Data, temp, tengah+1, kanan);
                        merge(Data, temp, kiri, tengah+1, kanan);
            }
}

void mergeSort(int Data[], int temp[], int array_size)

{
            m_sort(Data, temp, 0, array_size - 1);
}

int main()

23
 {
            int i;
            printf("Masukkan DATA SEBELUM TERURUT : \n");

            for (i = 0; i < MAX; i++)

            {
                        printf ("Data ke %i : ", i+1);
                        scanf ("%d", &Data[i]);
            }

            mergeSort(Data, temp, MAX);

            printf("\nDATA SETELAH TERURUT : ");
            for (i = 0; i < MAX; i++)
            printf("%d  ", Data[i]);
            printf("\n");
            //scanf("%d");
            return(0);
}

3.5 Radix Sort

#include <stdio.h>
#define MAX 20
#define SHOWPASS
#define BASE 10
void print(int *a, int n)
{
  int i;
  for (i = 0; i < n; i++)
    printf("%d\t", a[i]);
}

void radixsort(int *a, int n)

{
  int i, b[MAX], m = a[0], exp = 1;

24
  //Get the greatest value in the array a and assign it to m
  for (i = 1; i < n; i++)
 {
    if (a[i] > m)
      m = a[i];
 }

  //Loop until exp is bigger than the largest number

  while (m / exp > 0)
 {
    int bucket[BASE] = { 0 };

    //Count the number of keys that will go into each bucket
    for (i = 0; i < n; i++)
      bucket[(a[i] / exp) % BASE]++;

    //Add the count of the previous buckets to acquire the indexes after the end of
each bucket location in the array
    for (i = 1; i < BASE; i++)
      bucket[i] += bucket[i - 1]; //similar to count sort algorithm i.e. c[i]=c[i]+c[i-1];

    //Starting at the end of the list, get the index corresponding to the a[i]'s key,
decrement it, and use it to place a[i] into array b.
    for (i = n - 1; i >= 0; i--)
      b[--bucket[(a[i] / exp) % BASE]] = a[i];

    //Copy array b to array a

    for (i = 0; i < n; i++)
      a[i] = b[i];

    //Multiply exp by the BASE to get the next group of keys
    exp *= BASE;

    #ifdef SHOWPASS

25
      printf("\nPASS   : ");
      print(a, n);
    #endif
 }
}

int main()
{
  int arr[MAX];
  int i, n;
  printf("Enter total elements (n <= %d) : ", MAX);
  scanf("%d", &n);
  n = n < MAX ? n : MAX;

  printf("Enter %d Elements : ", n);

  for (i = 0; i < n; i++)
    scanf("%d", &arr[i]);

  printf("\nARRAY  : ");
  print(&arr[0], n);

  radixsort(&arr[0], n);

  printf("\nSORTED : ");
  print(&arr[0], n);
  printf("\n");

  return 0;
}

26
3.6 Tree Sort
#include <stdio.h>
#include <stdlib.h>

typedef struct _tree

{   int v;
    struct _tree *p, *l, *r;
} Tree;

void Ins(Tree **t, int val)

{   if(!(*t))
    {    *t = (Tree*)malloc(sizeof(Tree));
   
        (*t)->p = (*t)->l = (*t)->r = NULL;
        (*t)->v = val;
    }
    else if((*t)->v > val)
    {    Ins(&(*t)->l, val);
        (*t)->l->p = *t;
    }
    else
    {    Ins(&(*t)->r, val);
        (*t)->r->p = *t;
    }
}

void Print(Tree *t)

{   if(t)
    {    Print(t->l);
        printf("%d ", t->v);
        Print(t->r);
    }
}

27
int main()
{   
Tree *t = NULL;
    int n;
   
    while(scanf("%d", &n) && n != 0)
    Ins(&t, n);
    Print(t);

28
 BAB III
PRAKTIKUM

A. Program dan Output

Bubble Sort :
#include <stdio.h>

//inisialisasi array angka sebanyak 15 data

int angka[]={7,7,4,6,8,2,5,9,4,5,3,1,1,7,8};

//fungsi bubble sort ascending

void bubbleSortAsc(){
//mengulang sebanyak 14 kali sebanyak n-1 data
for(int i=0; i<15-1; i++){
for(int j=0; j<15-1; j++){
//jika angka index x+1 lebih kecil dari angka index x
if(angka[j+1]<angka[j]){
//tampung angka index x ke temp
int temp=angka[j];
//ubah angka index x menjadi angka index x+1
angka[j]=angka[j+1];
//ubah angka index x+1 menjadi angka temp
angka[j+1]=temp;
}
}
}
}

void bubbleSortDesc(){

29
 //mengulang sebanyak 14 kali sebanyak n-1 data
for(int i=0; i<15-1; i++){
for(int j=0; j<15-1; j++){
//jika angka index x+1 lebih besar dari angka index x
if(angka[j+1]>angka[j]){
//tampung angka index x ke temp
int temp=angka[j];
//ubah angka index x menjadi angka index x+1
angka[j]=angka[j+1];
//ubah angka index x+1 menjadi angka temp
angka[j+1]=temp;
}
}
}
}

int main(){
printf("Sebelum Sorting : \n");
for(int i=0; i<15; i++){
printf("%d ", angka[i]);
}
bubbleSortAsc();
printf("\n\nSetelah Sorting Ascending : \n");
for(int i=0; i<15; i++){
printf("%d ", angka[i]);
}
bubbleSortDesc();
printf("\n\nSetelah Sorting Descending : \n");
for(int i=0; i<15; i++){
printf("%d ", angka[i]);
}

30
 getchar();
return 0;
}

31
Output :

Insertion Sort :
#include <stdio.h>

int main ()
{
int angka[100];
int i, j, a, n;

printf("Masukkan jumlah data : "); scanf("%d", &n);

printf("Masukkan data :\n");
for (i = 0; i < n; ++i)
{
printf("Data ke-%d = ", i+1); scanf("%d", &angka[i]);
}

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

{

32
 for (j = i + 1; j < n; ++j)
{
if (angka[i] > angka[j])
{
a = angka[i];
angka[i] = angka[j];
angka[j] = a;
}
}
}

printf("\nSorting dalam bentuk descending\n");

for (i = 0; i < n; ++i)
{
printf("%d\t", angka[i]);
}
return 0;
}

Output :

33
B.

34
Selection Sort :
#include <stdio.h>

int main()
{
int a,b,temp,total;
int data[20];
printf("Masukkan jumlah data = ");scanf("%d",&total);
for(a=0;a<total;a++)
{
printf("masukkan nilai pada INDEX ke %d = ",a+1);scanf("%d",&data[a]);
}

for(a=0;a<total-1;a++)
{
for(b=a+1;b<total;b++)
{
if(data[a]>data[b])
{
temp=data[b];
data[b]=data[a];
data[a]=temp;
}
}
}

printf("\n\nData setelah diurut : ");

for(a=0;a<total;a++)
{
printf("%d ",data[a]);
}
printf("\n");

return 0;
}

35
36
Output :

Counting Sort :
#include <stdio.h>

int main()
{
int L[20], temp, i, j, n=6, idx;
printf("Masukkan 6 Element : \n");

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

{
printf("Masukkan Bilangan : "); scanf("%d", &L[i]);
}

printf("\nSebelum di sorting : ");

for(i=0; i<n; i++)
{
printf("%d ", L[i]);
}

37
 for(i=0; i<(n-1); i++)
{
idx=i;
for(j=i+1; j<n; j++)
{
if(L[j]<L[idx])
{
idx=j;
}
}
temp=L[i];
L[i]=L[idx];
L[idx]=temp;
}

printf("\nSetelah Sorting : ");

for(i=0; i<n; i++)
{
printf("%d ", L[i]);
}
printf("\n");
return 0;
}

Output :

38
Merge Sort :
//merge sort
#include <stdio.h>

int total,data[10],salin[10];
void input(){
printf("input a value = ");scanf("%d",&total);

for(int a=0;a<total;a++){
printf("masukkan nilai pada INDEX ke %d = ",a+1);scanf("%d",&data[a]);
}
}

void merge(int salin[],int lowptr,int highptr,int upperbound){

int x=0;
int lowerbound=lowptr;
int mid=highptr-1;
int n=upperbound-lowerbound+1;
while(lowptr<=mid && highptr<=upperbound){
if(data[lowptr]<data[highptr]){

39
salin[x++]=data[lowptr++];
}
else{
salin[x++]=data[highptr++];
}
while(lowptr<=mid){
salin[x++]=data[lowptr++];
}
while(highptr<=upperbound){
salin[x++]=data[highptr++];
}
for(int a=0;a<n;a++){
data[lowerbound+a]=salin[a];
}

}
}

void devide(int salin[],int kiri,int kanan){

if(kiri<kanan){
int mid=(kiri+kanan)/2;
devide(salin,kiri,mid);
devide(salin,mid+1,kanan);
merge(salin,kiri,mid+1,kanan);
}
}

void sort(){
devide(salin,0,total-1);
}

void view(){
for(int a=0;a<total;a++){
printf("%d ",data[a]);
}

40
printf("\n");
}

int main(){
input();
printf("sebelum di- sorting\n");
view();
sort();
printf("sesudah di- sorting\n");
view();
}

41
Output :

42
 BAB IV
PENUTUP

A. Kesimpulan
Dari penjelasan diatas bahwa
diantaranya : bubble sort, selection
kelebihan dan kekurangan tersendiri.
tujuan yang sama, yaitu mengurutkan
data akan menjadi sistematis.
sorting dibagi menjadi beberapa bagian,
sort dan insertion sort. Yang memiliki
Dari beberapa sorting tersebut memiliki
data untuk mempermudah pencarian dan

B. Saran
Adapun saran-saran yang dapat penulis sampaikan dalam hal ini adalah sebagai
berikut :

1.      Semoga pembaca dapat memahami dan mengerti tentang algoritma searching

dan sorting yang dijelaskan

2.      Dengan adanya makalah ini, diharapkan pembaca mendapat informasi terbaru

tentang algoritma-algoritma sorting dan searching.

3.      Semoga dengan membaca makalah ini, pembaca mendapat inspirasi-inspirasi

terbaru yang berguna dalam pembuatan algoritma-algoritma lainnya.

4.      Dalam kesempatan-kesempatan berikutnya sebaiknya ditambahkan

kemungkinan algoritma-algoritma baru sehingga ke depannya akan didapt lebih
banyak algoritma yang lebih efisien dan efektif

43
 DAFTAR PUSTAKA

http://kukuhapriyanto.blogspot.com/2017/06/sorting-dalam-bahasa-c.html?
m=1
http://pti-learning05.blogspot.com/2017/05/makalah-struktur-data-
sorting.html

44