Algoritma Sorting & Searching

0454T‐ Algoritma dan Metode Object Oriented Programming

LECTURE NOTES

Algoritma Sorting & Searching

Suharjito, S.Si, MT.

e-mail: [email protected]


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


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.


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:


// 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.


• 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


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.


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


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

}


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


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


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


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;

}

}


// 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.


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

}


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


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

}


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 12 16 39 27 38pivot

16 12 27 39 27 38pivot


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

}

}


// 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.


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.


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);

}


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,


// 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);

}


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


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]


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.


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

Algoritma Sorting & Searching

Documents

Transcript of Algoritma Sorting & Searching