Matakuliah: Algoritma Pemrograman II

Topik: Sorting Part II

Tanggal Pertemuan: Senin, 30 Maret 2020

Sorting Part II
Shell Sort

Metode ini disebut juga dengan metode pertambahan menurun (diminishing increment)
yang dikembangkan oleh Donald L. Shell, 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

Algorithm

1. Pertama-tama adalah menentukan jarak mula-mula dari data yang akan

dibandingkan, yaitu Max / 2. Data pertama dibandingkan dengan data dengan
jarak Max / 2. Apabila data pertama lebih besar dari data ke Max / 2 tersebut
maka kedua data tersebut ditukar. Kemudian data kedua dibandingkan dengan
jarak yang sama yaitu Max / 2. Demikian seterusnya sampai seluruh data
dibandingkan sehingga semua data ke-j selalu lebih kecil daripada data ke-(j +
Max / 2).
2. Pada proses berikutnya, digunakan jarak (Max / 2) / 2 atau Max / 4. Data
pertama dibandingkan dengan data dengan jarak Max / 4. Apabila data pertama
lebih besar dari data ke Max / 4 tersebut maka kedua data tersebut ditukar.
Kemudian data kedua dibandingkan dengan jarak yang sama yaitu Max / 4.
Demikian seterusnya sampai seluruh data dibandingkan sehingga semua data
ke-j lebih kecil daripada data ke-(j + Max / 4).
3. Pada proses berikutnya, digunakan jarak (Max / 4) / 2 atau Max / 8. Demikian
seterusnya sampai jarak yang digunakan adalah 1.

Step by step example

Sample Code

// C++ implementation of Shell Sort

#include <iostream>
using namespace std;

/* function to sort arr using shellSort */

int shellSort(int arr[], int n)
{
// Start with a big gap, then reduce the gap
for (int gap = n/2; gap > 0; gap /= 2)
{
// Do a gapped insertion sort for this gap size.
// The first gap elements a[0..gap-1] are already in gapped
order
// keep adding one more element until the entire array is
// gap sorted
for (int i = gap; i < n; i += 1)
{
// add a[i] to the elements that have been gap sorted
// save a[i] in temp and make a hole at position i
int temp = arr[i];

// shift earlier gap-sorted elements up until the correct

// location for a[i] is found
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
 arr[j] = arr[j - gap];

// put temp (the original a[i]) in its correct location

arr[j] = temp;
}
}
return 0;
}

void printArray(int arr[], int n)

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

int main()
{
int arr[] = {12, 34, 54, 2, 3}, i;
int n = sizeof(arr)/sizeof(arr[0]);

cout << "Array before sorting: \n";

printArray(arr, n);

shellSort(arr, n);

cout << "\nArray after sorting: \n";

printArray(arr, n);

return 0;
}
Selection Sort
Merupakan kombinasi antara sorting dan searching. Untuk setiap proses, akan dicari
elemen-elemen yang belum diurutkan yang memiliki nilai terkecil atau terbesar akan
dipertukarkan ke posisi yang tepat di dalam array. Misalnya untuk putaran pertama, akan dicari
data dengan nilai terkecil dan data ini akan ditempatkan di indeks terkecil (data[0]), pada putaran
kedua akan dicari data kedua terkecil, dan akan ditempatkan di indeks kedua (data[1]). Selama
proses, pembandingan dan pengubahan hanya dilakukan pada indeks pembanding saja,
pertukaran data secara fisik terjadi pada akhir proses.

Merupakan kombinasi antara sorting dan searching. Untuk setiap proses, akan dicari
elemen-elemen yang belum diurutkan yang memiliki nilai terkecil atau terbesar akan
dipertukarkan ke posisi yang tepat di dalam array. Misalnya untuk putaran pertama, akan dicari
data dengan nilai terkecil dan data ini akan ditempatkan di indeks terkecil (data[0]), pada putaran
kedua akan dicari data kedua terkecil, dan akan ditempatkan di indeks kedua (data[1]). Selama
proses, pembandingan dan pengubahan hanya dilakukan pada indeks pembanding saja,
pertukaran data secara fisik terjadi pada akhir proses.

Algorithm
1. Starting from the first element, we search the smallest element in the array, and

replace it with the element in the first position.

2. We then move on to the second position, and look for smallest element present

in the subarray, starting from index 1, till the last index.

3. We replace the element at the second position in the original array, or we can

say at the first position in the subarray, with the second smallest element.

4. This is repeated, until the array is completely sorted.

Step by step example

Sample Code

// C program implementing Selection Sort

# include <stdio.h>

// function to swap elements at the given index values

void swap(int arr[], int firstIndex, int secondIndex)
{
int temp;
temp = arr[firstIndex];
arr[firstIndex] = arr[secondIndex];
arr[secondIndex] = temp;
}

// function to look for smallest element in the given subarray

int indexOfMinimum(int arr[], int startIndex, int n)
{
int minValue = arr[startIndex];
int minIndex = startIndex;

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

if(arr[i] < minValue)
{
minIndex = i;
minValue = arr[i];
}
}
return minIndex;
}

void selectionSort(int arr[], int n)

{
for(int i = 0; i < n; i++)
{
 int index = indexOfMinimum(arr, i, n);
swap(arr, i, index);
}

void printArray(int arr[], int size)

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

int main()
{
int arr[] = {46, 52, 21, 22, 11};
int n = sizeof(arr)/sizeof(arr[0]);
selectionSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
Merge Sort

Merge sort merupakan algoritma pengurutan dalam ilmu komputer yang dirancang
untuk memenuhi kebutuhan pengurutan atas suatu rangkaian data yang tidak
memungkinkan untuk ditampung dalam memori komputer karena jumlahnya yang
terlalu besar. Algoritma ini ditemukan oleh John von Neumann pada tahun 1945.

Algoritma pengurutan data merge sort dilakukan dengan menggunakan cara divide and
conquer yaitu dengan memecah kemudian menyelesaikan setiap bagian kemudian
menggabungkannya kembali. Pertama data dipecah menjadi 2 bagian dimana bagian
pertama merupakan setengah (jika data genap) atau setengah minus satu (jika data
ganjil) dari seluruh data, kemudian dilakukan pemecahan kembali untuk masing-masing
blok sampai hanya terdiri dari satu data tiap blok.

Setelah itu digabungkan kembali dengan membandingkan pada blok yang sama
apakah data pertama lebih besar daripada data ke-tengah+1, jika ya maka data
ke-tengah+1 dipindah sebagai data pertama, kemudian data ke-pertama sampai
ke-tengah digeser menjadi data ke-dua sampai ke-tengah+1, demikian seterusnya
sampai menjadi satu blok utuh seperti awalnya. Sehingga metode merge sort
merupakan metode yang membutuhkan fungsi rekursi untuk penyelesaiannya.

Algorithm
1. Divide the problem into multiple small problems.
2. Conquer the subproblems by solving them. The idea is to break down the
problem into atomic subproblems, where they are actually solved.
3. Combine the solutions of the subproblems to find the solution of the actual
problem.

Step by step example

Sample Code

/*
a[] is the array, p is starting index, that is 0,
and r is the last index of array.
*/

#include <stdio.h>
// lets take a[5] = {32, 45, 67, 2, 7} as the array to be sorted.

// merge sort function

void mergeSort(int a[], int p, int r)
{
int q;
if(p < r)
{
q = (p + r) / 2;
mergeSort(a, p, q);
mergeSort(a, q+1, r);
merge(a, p, q, r);
}
}

// function to merge the subarrays

void merge(int a[], int p, int q, int r)
{
int b[5]; //same size of a[]
int i, j, k;
k = 0;
i = p;
j = q + 1;
while(i <= q && j <= r)
{
if(a[i] < a[j])
{
b[k++] = a[i++]; // same as b[k]=a[i]; k++; i++;
}
else
{
b[k++] = a[j++];
}
}

while(i <= q)
{
b[k++] = a[i++];
}

while(j <= r)
{
b[k++] = a[j++];
}

for(i=r; i >= p; i--)

{
a[i] = b[--k]; // copying back the sorted list to a[]
}
}

// function to print the array

void printArray(int a[], int size)
{
int i;
for (i=0; i < size; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}

int main()
{
int arr[] = {32, 45, 67, 2, 7};
int len = sizeof(arr)/sizeof(arr[0]);

printf("Given array: \n");

printArray(arr, len);

// calling merge sort

mergeSort(arr, 0, len - 1);

printf("\nSorted array: \n");

printArray(arr, len);
return 0;
}

Sumber
http://elektro.um.ac.id/wp-content/uploads/2016/04/MODUL-8-SORTING.pdf
https://sites.google.com/site/riksongultom/algoritma-pemrograman/insertion-sort
https://www.studytonight.com/data-structures/bubble-sort
https://www.geeksforgeeks.org/shellsort/
http://yuliana.lecturer.pens.ac.id/Struktur%20Data%20C/Prak%20SD%20-%20pdf/
Praktikum%208.pdf