algoritma sorting & searching
Post on 13-Aug-2015
150 Views
Preview:
DESCRIPTION
TRANSCRIPT
0454T‐ Algoritma dan Metode Object Oriented Programming
LECTURE NOTES
Algoritma Sorting & Searching
Suharjito, S.Si, MT.
e-mail: harjito@yahoo.com
0454T‐ Algoritma dan Metode Object Oriented Programming
LEARNING OUTCOMES
1. Mahasiswa dapat menerapkan algortima sorting dan searching dengan program C++
2. Mahasiswa dapat mendemonstrasikan algoritma sorting dasar (bubble sort, selection sort,
insertion sort) untuk pengurutan data
3. Mahasiswa dapat menggunakan algoritma quick sort dan merge sort untuk mengurutkan data
4. Mahasiswa dapat menjelaskan algoritma searching (sequential, binary dan interpolation)
OUTLINE MATERI :
1. Definisi sorting
2. Algoritma sorting dasar
3. Algoritma sorting lanjut
4. Definisi searching
5. Algoritma searching
0454T‐ Algoritma dan Metode Object Oriented Programming
ISI
SORTING ALGORITHM Macam-macam Sorting Algorithm:
1. Selection Sort
2. Bubble Sort
3. Insertion Sort
4. Merge Sort
5. Quick Sort
Selection Sort (Ascending):
Pengurutan dilakukan dengan memilih elemen terbesar dan menempatkan pada posisinya,
kemudian mencari element terbesar berikutnya dan menempatkan pada tempatnya, dan
seterusnya.
Algoritmanya:
1. Cari data yang paling besar pada array.
2. Tukarkan nilai terbesar tersebut dengan nilai array pada posisi paling akhir.
3. Abaikan posisi terakhir dengan nilai terbesarnya dan cari nilai terbesar dari array sisanya.
4. Proses dilanjutkan sampai ditemukan dan ditukarkan N-1 dari N elemen array.
0454T‐ Algoritma dan Metode Object Oriented Programming
Contoh proses Selection Sort pada array 5 bilangan Integer:
Kotak yang diarsir adalah kotak yang dipilih, sedangkan elemen yang di bold adalah yang
sudah terurut pada posisinya.
// Sort the item in an array into ascending order
void SelectionSort(dataType *A, int N) {
// Last = index of the last item in the subarray
// L = index of the largest item found
for (int Last = N-1; Last >= 1; --Last)
{
// Select the largest item in A[0, …, Last]
int L = IndexOfLargest( A, Last+1);
// Swap largest item A[L] with A[Last]
Swap( A[L], A[Last] );
}
}
29 10 14 37 13
29 10 14 13 37
13 10 14 29 37
13 10 14 29 37
10 13 14 29 37
Initial Array:
After 1st swap:
After 2nd swap:
After 3rd swap:
After 4th swap:
0454T‐ Algoritma dan Metode Object Oriented Programming
// Find the largest item in the array
int IndexOfLargest( const dataType *A, int Size ) {
int indexLargest = 0;
for ( int index = 1; index < Size; ++index )
{
if (A[index] >= A[indexLargest]
idexLargest = index;
}
return indexLargest;
}
// Swaps X and Y
void Swap( dataType& X, dataType& Y) {
dataType temp = X;
X = Y;
Y = temp;
}
Insertion Sort:
Insertion membagi array menjadi dua bagian yaitu wilayah sorted dan wilayah unsorted:
• awalnya, daerah sorted adalah A[0], dan daerah unsorted adalah A[1, … N-1].
• Ambil elemen pada daerah unsorted dan sisipkan pada posisi yang benar pada daerah
sorted.
0454T‐ Algoritma dan Metode Object Oriented Programming
• Setelah iterasi ke i, daerah sorted adalah A[0, … i], dan daerah unsorted adalah
A[i+1, … N-1].
• Pada setiap langkah daerah sorted bertambah satu dan daerah unsorted berkurang
satu.
Proses Insertion Sort pada array 5 bilangan integer:
Insert 14, Copy 37, Insert 37 on top of itself
29 10 14 37 13
29 29 14 37 13
10 29 14 37 13
10 29 29 37 13
10 14 29 37 13
10 14 29 37 13
10 14 14 29 37
10 13 14 29 37
Initial
Sorted
Copy 10
Shift 29
Insert 10, Copy 14
Shift 29
Copy 13
Shift 14, 29, 37
Insert 13
0 i N-1
Sorted Unsorted
0454T‐ Algoritma dan Metode Object Oriented Programming
Fungsi Insertion sort pada array dengan N elemen:
void InsertionSort( dataType *A, int N) {
// Unsorted = index pertama dari array unsorted
// Loc = index of insertion in the sorted region
// NextItem = next item in the unsorted region
for (int Unsorted = 1; Unsorted < N; ++ Unsorted)
{
dataType NextItem = A[Unsorted];
int Loc = Unsorted;
for (; (Loc > 0) && (A[Loc-1]) > NextItem; --Loc)
A[Loc] = A[Loc-1];
// Insert NextItem into sorted region
A[Loc] = NextItem;
}
}
Bubble Sort:
Bubble sort dilakukan dengan membandingkan dua elemen yang bendampingan dan
menukarkannya jika kedua elemen tersebut belum terurut. Pengurutan ini biasanya memerlukan
banyak passing terhadap datanya. Pada passing pertama dibandingkan data pertama dan kedua
kemuidan data ditukarkan jika belum terurut, selanjutnya dibandingkan pasangan data
selanjutnya yaitu data kedua dan ketiga dan ditukarkan jika belum terurut. Proses dilanjutkan
sampai pada pasangan terakhir dari array.
0454T‐ Algoritma dan Metode Object Oriented Programming
29 10 14 37 13
10 29 14 37 13
10 14 29 37 13
10 14 29 37 13
10 14 29 13 37
Initial Array: Pass 1:
10 14 29 13 37
10 14 29 13 37
10 14 29 13 37
10 14 13 29 37
Pass 2:
Pass 3: 10 14 13 29 37
10 14 13 29 37
10 13 14 29 37
0454T‐ Algoritma dan Metode Object Oriented Programming
C++ fungsi BubbleSort untuk mengurutkan array N elemen secara Ascending:
void BubbleSort( dataType *A, int N)
{
enum boolean {FALSE, TRUE};
boolean Sorted = FALSE;
for (int Pass = 1; (Pass < N) && !Sorted; ++Pass)
{
Sorted = TRUE;
for (int Index = 0; Index < N-Pass; ++Index)
{
int NextIndex = Index + 1;
if (A[Index] > A[NextIndex])
{
// exchange item
Swap( A[Index], A[NextIndex] );
Sorted = FALSE;
} // end if
} // end for
} // end for
}
0454T‐ Algoritma dan Metode Object Oriented Programming
MERGE SORT
Merge sort merupakan algoritma pengurutan recursive yang selalu memberikan unjuk kerja yang
sama.
Mergesort dilakukan dengan membagi array menjadi dua bagian, kemudian mengurutkan tiap
bagian dan menggabungkan keduanya menjadi satu array terurut.
Mergesort dapat dijelaskan dengan gambar sebagai berikut:
Merge the halves pada gambar di atas dilakukan dengan:
1. 1 < 2, maka inputkan 1 dari left half ke dalam TempArr
2. 4 > 2, maka inputkan 2 dari left half ke dalam TempArr.
3. 4 > 3, maka inputkan 3 dari right half ke dalam TempArr
4. Right half selesai, maka inputkan sisa elemen pada left half ke TempArr.
8 1 4 3 2
2 3
1 2 3 4 8
1 4 8
1 2 3 4 8
Divide the array in half
Sort the halves
Merge the halves
Copy TempArr into original arrayTempArr
a b c d
0454T‐ Algoritma dan Metode Object Oriented Programming
Pseudocode dari Mergesort adalah:
Mergesort (A, F, L)
// Sorts A[F … L] by
// 1. Sorting the first half of the array
// 2. Sorting the second half of the array
// 3. Merging the two sorted halves
if (F < L)
{
Mid = (F + L )/2 // get the midpoint
Mergesort(A, F, Mid) // sort A[F … Mid]
Mergesort(A, Mid+1, L) // sort A[Mid+1 … L]
// merge the sorted A[F … Mid] and A[Mid+1 … L]
Merge(A, F, Mid, L)
}
else quit
0454T‐ Algoritma dan Metode Object Oriented Programming
Bentuk recursive dari mergesort:
Program C++ dari Mergesort adalah:
void Mergesort(dataType *A, int F, int L)
{
if (F < L)
{
int Mid = (F + L)/2; // index of midpoint
Mergesort(A, F, Mid); // sorted the left half
Mergesort(A, F, Mid); // sorted the right half
Merge(A, F, Mid, L); // merge the two halves
}
}
38 16 27 39 12 27
38 16 27
38 16 27
38 16
16 38
16 27 38
39 12 27
39 12 27
39 12
12 39
12 27 39
12 16 27 27 38 39
Recursive calls to Mergesort
Merge steps
0454T‐ Algoritma dan Metode Object Oriented Programming
void Merge(dataTye *A, int F, int Mid, int L)
{
dataType TempArr[MAX_SiZE]; // temporary array
// inisialisasi index local dari subarray
int First1 = F;
int Last1 = Mid;
int First2 = Mid+1;
int Last2 = L;
int Index = First1;
for (; (First1 <= Last1) && (First2 <= Last2); ++Index)
{
if (A[First1 < A[First2])
{
TempArr[Index] = A[First1]
++First1;
}
else
{
TempArr[Index] = A[First2]
++First2;
}
}
0454T‐ Algoritma dan Metode Object Oriented Programming
// finish off the nonempty subarray
// finish off the first subarray, if necesary
for (; First1 <= Last1; ++First1, ++Index)
TempArr[Index] = A[First1];
// finish off the second subarray, if necesary
for (; First2 <= Last2; ++First2, ++Index)
TempArr[Index] = A[First2];
// copy the result back into the original array
for (Index=F; Index <=L; ++Index)
A[Index] = TempArr[Index];
}
QUICK SORT
Hampir sama dengan merge sort, Quick sort merupakan metode pengurutan recursive dengan
membagi array menjadi dua bagian.
Bedanya dengan merge sort, proses recursive pada quicksort dilakukan setelah proses partisi
selesai.
Proses pemisahan array pada quicksiort berdasarkan suatu nilai elemen tertentu dari array yang
diurutkan, sedangkan pada mergesort partisi array berdasarkan jumlah elemen dari array yang
akan diurutkan.
0454T‐ Algoritma dan Metode Object Oriented Programming
Pseudocode dari fungsi quicksort adalah:
QuickSort(A, F, L)
{
if (F < L)
{
Choose the pifot item p from A[F, …,L]
Partition the items of A[F, …,L] about p
// the partition is A[F, …pivotIndex, …,L]
// sort S1
QuickSort(A, F, pivotIndex-1)
// sort S2
QuickSort(A, pivotIndex+1, L)
}
else
quit
}
0454T‐ Algoritma dan Metode Object Oriented Programming
Dapat dijelaskan dengan gambar sbb:
Pengambilan pivot item biasanya adalah item yang pertama, sehingga dapat digambarkan sbb:
• Pseudocode dari fungsi partition adalah:
Partition(A, F, L, pivotIndex)
{
P = A[F] // choose the pivot p
LastS1 = F // initialize S1 and S2 to empty
// set the unknown region to A[F+1, …, L]
FirstUnknown = F+1
< p >= p p
S1 S2
F L
pivotIndex
p < p
S1
>= p
S2
F L
?
Unknown
LastS1 FirstUnknown
pivot
0454T‐ Algoritma dan Metode Object Oriented Programming
while (FirstUnknown <= L)
{
if (A[FirstUnknown] < p)
Move A[FirstUnknown] into S1
else
Move A[FirstUnknown] into S2
}
//
Swap A[F] with A[LastS1]
PivotIndex = LastS1
}
0454T‐ Algoritma dan Metode Object Oriented Programming
Proses Partisi dengan pivot elemen pertama dari array adalah:
27 38 12 39 27 16Array awal
pivot
27 38 12 39 27 16pivot Unknown
27 12 38 39 27 16 pivot Unknown
27 38 12 39 27 16pivot Unknown
27 12 38 39 27 16pivot Unknown
27 12 38 39 27 16pivot Unknown
27 12 16 39 27 38pivot
16 12 27 39 27 38pivot
0454T‐ Algoritma dan Metode Object Oriented Programming
Program:
// function partition A[F … L] for quicksort
// s1 = A[F … PivotIndex-1] < Pivot
//A[PivotIndex] == Pivot
// s2 = A[PivotIndex+1 … L] >= Pivot
// Call function Swap(a,b)
void Partition(dataType *A, int F, int L, int& PivotIndex)
{
// Initialy everything but pivot is in unknown
dataType Pivot = A[F];
int LastS1 = F;
int FirstUnknown = F+1;
// move one item at a time until unknown region is empty
for (; FirstUnknown <= L; ++FirstUnknown)
{
if ( A[FirstUnknown] < Pivot )
{
++LastS1;
Swap( A[FirstUnknown] , A[LastS1] );
}
}
0454T‐ Algoritma dan Metode Object Oriented Programming
// place pivot in proper position and mark its location
Swap( A[F] , A[LastS1] );
PivotIndex = LastS1;
}
// Function quickSort
// Sort the item in the array into ascending order
// call function Partition
void QuickSort(dataType *A, int F, int L)
{
int PivotIndex;
if (F < L)
{
// create the partition S1, pivot, S2
Partition(A, F, L, PivotIndex);
//sort region S1 and S2
QuickSort(A, F, PivotIndex-1);
QuickSort(A, PivotIndex+1, L);
}
}
Algoritma Searching
Untuk melakukan pencarian pada suatu record dalam suatu list digunakan kunci (key).
Kunci harus unik, artinya tidak boleh ada kunci yang sama dalam satu list.
0454T‐ Algoritma dan Metode Object Oriented Programming
Kunci yang merupakan bagian dari record disebut kunci intern (Internal key). Kunci yang tidak
merupakan bagian dari record, tetapi berkaitan dengan record disebut kunci luar (external key),
biasanya berupa file indeks.
Contoh: Suatu record data mahasiswa terdiri dari (NIM, Nama, Alamat, Jenis_klamin,
Tanggal_lahir).
NIM digunakan sebagai kunci karena NIM merupakan atribut yang bersifat unik, tidak ada yang
sama.
Metode Pencarian (Searching Methods):
1. Sequential Search
2. Binary Search
3. Interpolation Search
Sequential Search
Merupakan suatu teknik pencarian yang sederhana dan langsung, dapat digunakan pada struktur
data array maupun linked-list, dan data tidak perlu urut.
Algoritma sequential search:
Misal N: banyaknya record dalam list array Data,
1. Untuk setiap Data[i]; 0 ≤ i ≤ N-1, uji apakah Data[i] = Kunci.
2. Bila Data[i] = Kunci, Indeks = i, selesai.
3. Bila Data[i] <> Kunci, lanjutkan pencarian hingga i = N-1.
0454T‐ Algoritma dan Metode Object Oriented Programming
4. Bila i = N-1 dan Data[i] <> Kunci, Indeks = -1.
5. Selesai.
Indeks = i, berarti data yang dicari ada pada posisi i, sedangkan Indeks = -1, berarti data yang
dicari tidak ditemukan.
Program C++ dari sequential search:
// --------------------------------------------------------------------
// Fungsi SequentialSearch untuk mencari data Key
// pada array X dengan jumlah elemen N,
// Return index array jika data ada,
// Return –1 jika data key tidak ada.
//--------------------------------------------------------------------
int SequentialSearch(int *X, int Key, int N)
{
int Index;
for (Index=0; Index<N; Index++)
if (Key == X[Index])
return(Index);
return(-1);
}
0454T‐ Algoritma dan Metode Object Oriented Programming
Binary Search
Teknik ini hanya dapat dilakukan pada list yang telah terurut dan berada pada struktur data array.
Algoritma Binary search:
N: banyaknya record dalam list array X
1. Kiri = 0 dan Kanan = N-1
2. Tengah = (int)(Kiri + Kanan)/2
3. Bila X[Tengah] = Kunci, maka
Indeks = Tengah, selesai.
4. Bilai X[Tengah] < Kunci, maka
Kanan = Tengah - 1.
5. Bilai X[Tengah] > Kunci, maka
Kiri = Tengah + 1.
6. Bila Kiri <= Kanan, dan X[Tengah] <> kunci, Ulangi mulai dari 2.
7. bila X[Tengah] <> Kunci, Indeks = -1.
8. Selesai.
Program C++ dari BinarySearch:
// ----------------------------------------------------------------------
// Fungsi BinarySearch untuk mencari data key pada
// array X dengan jumlah elemen N,
0454T‐ Algoritma dan Metode Object Oriented Programming
// Return Index dari array jika data ada, dan
// Return –1 jika data key tidak ada.
//-----------------------------------------------------------------------
int BinarySearch(int *X, int Key, int N)
{
int Mid;
int low = 0;
int hight = N-1;
while (low <= hight) {
Mid = (int)(low + hight)/2;
if (Key == X[Mid])
return(Mid);
if (Key < X[Mid])
hight = Mid – 1;
else
low = Mid + 1;
}
return(-1);
}
0454T‐ Algoritma dan Metode Object Oriented Programming
Contoh, pencarian biner pada daftar mahasiswa dengan kunci=NIM, dan target = 112 (Ursula).
Indeks Nama NIM
0 Ahmad 034
1 Zamzawi 065
2 Ursula 112
3 Hamdan 116
4 Budiman 124
5 Rahayu 176
6 Usman 178
7 Fifi 187
8 Alex 190
9 Lukman 208
10 Widodo 214
11 Tiur 268
12 Halim 333
13 Riyanto 424
0454T‐ Algoritma dan Metode Object Oriented Programming
Interpolation Search
Teknik pencarian ini menggunakan rumus umum:
Kunci – X[min]
P = ------------------------
X[max] – X[min]
Posisi = round(P*(max – min)) + min
Contoh suatu list terdiri dari 100 record, kunci paling rendah = 220, tertinggi = 980 , target =
743.
Maka perkiraan posisi target:
743 –220
------------- x 100 = 0,69
980 – 220
Posisi taksiran = 0.69 x 100 = 69.
Apakah X[69] = 743 (Kunci) ?
Bila Kunci > X[69]
Maka: X[min] = X[69+1],
sedangkan X[max] tetap
Bila Kunci < X[69]
Maka: X[min] tetap,
sedangkan X[max] = X[69 –1]
0454T‐ Algoritma dan Metode Object Oriented Programming
SIMPULAN
• Algoritma sorting digunakan untuk mengurutkan sekumpulan data baik secara ascending
(urutan dari kecil ke besar) maupun secara descending (urutan dari besar ke kecil)
• Metode pengurutan data dasar adalah bubble sort, selection sort dan insertion sort, sedangkan
pengurutan data lanjut adalah quick sort dan merge sort.
• Data perlu diurutkan dengan tujuan untuk mempercepat pencarian data.
• Metode pencarian yang mengharuskan data terurut adalah binary search dan interpolation
search, sedangkan metode searching yang tidak mensyaratkan data harus diurutkan terlebih
dulu adalah metode sequential search.
0454T‐ Algoritma dan Metode Object Oriented Programming
DAFTAR PUSTAKA
1. Deitel & Deitel. (2010). C++ HOW TO PROGRAM. 7th Edition. Prentice Hall Intern. New
Jersey.
2. Robert Sedgewick. (1992). Algorithms in C++. 2. Addison -Wesley. New York.
3. Bjarne, Stroustrup. (2000). The c++ programming language. 3. Addison Wesley. New York.
4. http://linux.wku.edu/~lamonml/algor/sort/sort.html
5. http://linux.wku.edu/~lamonml/algor/sort/bubble.html
6. http://linux.wku.edu/~lamonml/algor/sort/selection.html
7. http://linux.wku.edu/~lamonml/algor/sort/insertion.html
8. http://linux.wku.edu/~lamonml/algor/sort/quick.html
9. http://cprogramming.com/discussionarticles/sorting_and_searching.html
10. http://www.dcc.uchile.cl/~rbaeza/handbook/algs/3/321.srch.c.html
top related