MAKALAH

STRUKTUR DATA

NAMA MAHASISWA :
SUPRATMAN
NIM:2104082

POKOK PEMBAHASAN:
1. MATERI SEARCHING
2. MATERI SORTING

DOSEN PENGAMPU:
AGUNG SETIAWAN,S,Kom,, MM., M.Kom

STKIP KEGURUAN TINGGI JURUSAN PENDIDIKAN TEKNOLOGI

INFORMASI (B) KAMPUS STKIP ROKANIA TAHUN AJARAN
2021/2022
 KATA PENGANTAR

Bismillahirrahmanirrahim.

Assalamu’alaikum Wr.Wb.

Puji syukur kami panjatkan kehadirat Allah SWT, yang telah

melimpahkan berbagai rahmat Karunia-Nya sehingga kami masih

diberi kesempatan untuk menyelesaikan tugas Makalah ini guna

memenuhi tugas mata kuliah Struktur Data. Sholawat serta salam

semoga senantiasa tercurahkan kehadirat Nabi kita Muhammad SAW,

keluarga,sahabat, dan para pengikutnya yang tetap setia menjaga dan

mengikuti sunnahnya hingga akhir zaman. Dalam penyusunan STD ini,

tidak sedikit hambatan yang kami hadapi. Namun dengan penuh

kesabaran dan terutaman pertolongan dari Allah SWT akhirnya

Makalah ini dapat terselesaikan, tetapi kami menyadari masihbanyak

kekurangan dan jauh dari sempurna, oleh karena itu saran dan kritik

yang kontruktif dari semua pihak terutama dari Bapak Dosen

pembimbing mata kuliah ini sangat kami harapkan demi perbaikan

dimasa yang akan datang. Semoga Makalah STD ini, dapat bermanfaat

dan berguna untuk para mahasiswa, atas perhatiannya kami ucapkan

terima kasih.

Pasir Pangaraian, 08 Juni 2022

 BAB I

MATERI SEARCHING

1. Pengertian Searching (Pencarian)

Pencarian (searching) merupakan proses yang sering digunakan   dalam

pengelolaan data. Proses pencarian adalah menemukan nilai (data)

tertentu di dalam sekumpulan data yang bertipe sama (baik bertipe

dasar atau bertipe bentukan). Search algoritma adalah algoritma yang

menerima argument A dan mencoba untuk mencari record yang mana

keynya adalah A.

Algoritma bisa mengembalikan nilai record, atau pointer ke record.

Reord sendiri adalah tipe data yang terdiri atas kumpulan variabel

disebut field. Sequential search (penelusuran sequensial) yaitu proses

mengunjungi melalui suatu pohon dengan cara setiap simpul di

kunjungi hanya satu kali yang disebut dengan tree transversal /

kunjungan pohon.

Data dapat disimpan secara temporer dalam memori utama atau

disimpan secara permanen di dalam memori sekunder (tape atau disk).

Di dalam memori utama, struktur penyimpanan data yang umum adalah

berupa larik atau tabel (array), sedangkan di dalam memori sekunder

berupa arsip (file).

Aktivitas yang berkaitan dengan pengolahan data ini sering di dahului

dengan proses pencarian. Sebagai contoh, untuk mengubah (update)

data tertentu, langkah pertama yang harus dilakukan adalah mencari

keberadaan data tersebut di dalam kumpulannya. Aktivitas yang awal

sama juga dilakukan pada proses penambahan (insert) data yang baru.

Proses penambahan data dimulai dengan mencari apakah data yang

ditambahkan sudah terdapat di dalam kumpulan. Jika sudah dan

mengasumsikan tidak boleh ada duplikasi data,maka data tersebut tidak

perlu di tambahkan, tetapi jika belum ada, maka tambahkan.

a. Pencarian Linier/Sekuensial

Sequential search adalah suatu teknik pencarian data dalam array ( 1

dimensi ) yang akan menelusuri semua elemen-elemen array dari awal

sampai akhir, dimana data-data tidak perlu diurutkan terlebih dahulu.

Kemungkinan terbaik (best case) adalah jika data yang dicari terletak

di indeks array terdepan (elemen array pertama) sehingga waktu yang

dibutuhkan untuk pencarian data sangat sebentar (minimal).

Kemungkinan terburuk (worst case) adalah jika data yang dicari

terletak di indeks array terakhir (elemen array terakhir) sehingga waktu

yang dibutuhkan untuk pencarian data sangat lama (maksimal).

Prinsip kerja dari Sequential Searching ini adalah semua data di cek

oleh variabel cari. Sequential search dibedakan menjadi dua macam

yaitu Pencarian beruntun pada larik tidak terurut dan pencarian

beruntun pada larik terurut. Berikut adalah 2 fakta penting tentang

Pencarian linier:

 Hanya bagus untuk dipakai pada data yang diacak/tak terurut

(unsorted).

 Kompleksitasnya adalah O(n).

1. Pencarian beruntun pada larik tidak terurut atau acak

Pencarian dilakukan dengan memeriksa setiap elemen larik mulai dari

elemen pertama sampai elemen yang dicari ditemukan atau sampai

seluruh elemen sudah diperiksa.

Diketahui sebuah tabel TabInt [1..N] yang telah berisi nilai dengan tipe

integer. Jika pada tabel tersebut akan dicari apakah harga/nilai X ada

dalam TabInt tersebut ? Maka pencarian yang akan dilakukan adalah

membandingkan setiap nilai pada tabel tersebut dengan nilai X yang

dicari. Proses tersebut dilakukan secara berurutan mulai dari elemen

pertama sampai ketemu, atau sampai elemen terakhir. Apabila niali X

ditemukan maka harga/nilai indeks I di mana X diketemukan pertama

kalinya akan bernilai tidak sama dengan nol (I ¹ 0). I diberi harga 0 jika

pencarian tidak ketemu. Pencarian segera dihentikan begitu harga

pertama diketemukan.

Contoh: 13 87 14 21 75 53

 Misal nilai yang dicari adalah X = 21, maka elemen yang diperiksa

adalah 13, 87, 14, 21. (ditemukan) Jadi indeks larik yang

dikembalikan : I = 4.

 Misal nilai yang dicari adalah X = 15, maka elemen yang diperiksa

adalah 13, 87, 14, 21, 75, 53. (tidak ditemukan) Jadi indeks larik

yang dikembalikan : I = 0.

DETAIL PROGRAM

#include <stdio.h>
#include <conio.h>

void main(){

            clrscr();

            int data[21] = {13, 87, 14, 21, 75, 53};

            int cari;

            int flag=0;

            printf("masukkan data yang ingin dicari =

");             scanf("%d",&cari);

            for(int i=0;i<21;i++){

                        if(data[i] == cari) flag=4;}

            if(flag==1) printf("Data ada!\n");

         else printf("Data tidak ada!\n");}

2. Pencarian beruntun pada larik terurut

Pencarian dilakukan dengan memeriksa setiap elemen larik yang

berurutan mulai dari elemen pertama sampai elemen yang dicari

ditemukan atau sampai seluruh elemen sudah diperiksa.

Diketahui sebuah tabel bilangan integer TabInt[1..N], yang telah diisi

dan isinya terurut membesar ( untuk setiap i anggota dari [1..N-1], Ti <

T i+1). Jika pada tabel tersebut akan dicari apakah harga/nilai X ada

dalam TabInt tersebut ? Maka pencarian yang akan dilakukan adalah

membandingkan setiap nilai pada tabel tersebut dengan nilai X yang

dicari. Proses tersebut dilakukan secara berurutan mulai dari elemen

pertama sampai ketemu, atau sampai kepada elemen terakhir atau

sampai dengan harga X yang beinilai lebih besar dari nilai elemen

suatu posisi yang sedang diakses pada tabel. Apabila niali X ditemukan

maka harga/nilai indeks I di mana X diketemukan pertama kalinya akan

bernilai tidak sama dengan nol (I ¹ 0). I diberi harga 0 jika pencarian

tidak ketemu.

Contoh : 55 56 78 80 100 156 199

 Misal nilai yang dicari adalah X = 100, maka elemen yang diperiksa

adalah 55, 56, 78, 80, 100. (ditemukan) Jadi indeks larik yang

dikembalikan : I = 5.

 Misal nilai yang dicari adalah X = 170, maka elemen yang diperiksa

adalah 55, 56, 78, 80, 100, 156, 199. (tidak ditemukan) Jadi indeks

larik yang dikembalikan : I = 0.

DETAIL PROGRAM

#include <stdio.h>

#include <conio.h>

void main(){

            clrscr();

            int data[100] = {55,56,78,80,100,156,199};

            int cari;

            int flag=0;

            printf("masukkan data yang ingin dicari =

");             scanf("%d",&cari);

            for(int i=0;i<100;i++){

                        if(data[i] == cari) flag=1;}

            if(flag==1) printf("Data ada!\n");

         else printf("Data tidak ada!\n");}

 Dari program di atas, terlihat bahwa dilakukan perulangan untuk

mengakses semua elemen array dan satu per satu berdasarkan

indeksnya.
 Program menggunakan sebuah variable flag yang berguna untuk
menandai ada atau tidaknya data yang dicari dalam array data.

Hanya bernilai 0 atau 1.

 Flag pertama kali di inisialisasi dengan nilai 0.

 Jika ditemukan, maka flag akan di set menjadi satu, jika tidak ada
maka flag akan tetap bernilai 0.

 Semua elemen array data akan dibandingkan satu per satu dengan
data yang dicari dan diinputkan oleh user.
a. Contoh program
Program pencarian ;

Uses crt;

Label 1;

Var

L:array [1..100] of integer;

Bil,I,n:integer;

ul:char;

procedure tampil;

begin

write (‘masukan banyak data:’); readln (n);

for i:=1 to n do

begin

write (‘data [‘,I,’] :’);readln (L [i]);

end;

end;

procedure seq_search;

begin

write (‘angka yang akan di cari:’);readln (bil);

i : =1;
while (I <n) and (L[i] <> bil) do

begin

i:=i+1;

end;

if (L[i]=bil)then

writeln (‘ditemukan pada elemen larik ke’,i)

else

writeln (‘tidak ditemukan’);

end;

begin

1:

Clrscr;

Writeln (‘----------------------------------------------------------’);

Writeln (‘------ PROGRAM PENCARIAN ANGKA ----‘);

Writeln (‘----------------------------------------------------------‘);

Tampil;

Seq_search;

Writeln ;

Delay (3000);

Write (‘apakah anda ingin mengulangi [Y/T] ? : ‘);readln (ul);

If (ul =’Y’) or (ul =’y’) then

Goto 1 ;

Readkey;

End.
a. Pencarian Binner

Pencarian Biner (Bah.Ingg: Binary Search) adalah pencarian data

secara eliminasi biner berulang/terus-menerus. Maksudnya adalah pada

saat pencarian data, 1 kelompok data yang sudah urut dibagi menjadi 2

subkelompok. Lalu salah satu subkelompok dieliminasi, sehingga ruang

lingkup pencarian data menjadi lebih sedikit. Kemudian subkelompok

yang tersisa dibagi lagi menjadi 2 subkelompok lagi, demikian

dilakukan secara berulang-ulang.

Sebagai contoh, misalnya diinginkan mencari data nama  Irawan di

sekumpulan data nama yang sudah terurut. Apabila kelompok data ini

dibagi 2, ternyata di bagian tengah terdapat nama  Leny. Maka

subkelompok data sesudah Leny akan dieliminasi, karena tidak

mungkin nama Irawan akan terdapat pada data huruf L s/d Z.

Sedangkan, subkelompok sebelum Leny, kemudian akan dibagi 2 lagi,

dan diperiksa ulang. Ternyata kali ini di bagian tengah terdapat

nama Gery. Maka kelompok data sebelum Gery akan dieliminasi,

karena tidak mungkin terdapat data Irawan pada huruf A s/d G.

Demikian seterusnya terjadi, proses eliminasi ruang lingkup pencarian

data menjadi semakin sedikit secara berulang.

Berikut adalah 3 fakta penting mengenai pencarian biner:

 Hanya bisa berfungsi pada data yang sudah terurut ( sorted), ini

adalah syarat mutlak dari pencarian biner.

 Merupakan salah satu contoh penerapan cara kerja

dari konsep Divide and Conquer

 Kompleksitasnya adalah O(lg n)

Ini adalah implementasi dari pencarian biner memakai  function untuk

pencarian data bertipe string:

type

   TArrString = array of string;

function CariBiner(var Arr: TArrString; Cari: string):

LongInt;

var

   Awal, Akhir, Tengah, Ketemu: LongInt;

begin

   Awal:= Low(Arr);

   Akhir:= High(Arr);

   Ketemu:= -1;

   while (Awal <= Akhir) and (Ketemu = -1) do begin

      Tengah:= (Awal + Akhir) shr 1;

      if Arr[Tengah] = Cari then Ketemu:= Tengah else

begin

         if Cari < Arr[Tengah] then Akhir:= Tengah-1 else

Awal:= Tengah+1;

      end;

   end;

   CariBiner:= Ketemu;

end;
penjelasannya :

type

   TArrString = array of string;

function CariBiner(var Arr: TArrString; Cari: string):

LongInt;

var

   Awal, Akhir, Tengah, Ketemu: LongInt;

begin

   Awal:= Low(Arr);   // Posisi awal pencarian

   Akhir:= High(Arr); // Posisi akhir pencarian

   Ketemu:= -1;       // Asumsi awal: belum ketemu

   // Ulangi selama ruang lingkup pencarian masih ada

(Awal <= Akhir)

   // dan data yang dicari belum ketemu (Ketemu = -1)

   while (Awal <= Akhir) and (Ketemu = -1) do begin

      // Hitung lokasi data yang di tengah ruang lingkup

pencarian

      Tengah:= (Awal + Akhir) shr 1;

      { Cek apakah data yang di tengah merupakan data yang

dicari,

        apabila bukan, pindahkan ruang lingkup pencarian,

        kalau data ada di sebelah kiri (lebih kecil <),

        maka batas akhir yang dikurangi (Akhir:= Tengah -

1),

        sedangkan jika data ada di sebelah kanan,

         maka batas awal yang ditambah (Awal:= Tengah +

1) }

      if Arr[Tengah] = Cari then Ketemu:= Tengah else

begin

         if Cari < Arr[Tengah] then Akhir:= Tengah-1 else

Awal:= Tengah+1;

      end;

   end;
   CariBiner:= Ketemu;
end;
 KESIMPULAN

Dari analisa data, kami dapat mengambil kesimpulan sebagai berikut:

1. Pencarian adalah proses menemukan data tertentu di dalam

sekumpulan data yang bertipe sama (tipe dasar atau tipe bentukan).

2. Salah satu metode yang dapat kita gunakan adalah metode

Pencarian Beruntun (sequential search).

3. Metode pencarian beruntun (sequential search) adalah metode yang

paling sederhana dari sejumlah metode pencarian.

4. Secara singkat Metode pencarian beruntun (sequential search) dapat

dijelaskan sebagai berikut :

Dari elemen-elemen yang di ketahui, data yang dicari di bandingkan

satu persatu sampai data tersebut ditemukan atau tidak di temukan.

 BAB II

MATERI SORTING

1. Sorting

a. 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)

k = j;

swap(array[i],array[k]);

b. Selection 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]);

c. Merge Sort
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 merg sort secara

rekursif.

3. Kombinasi
 Mengkombinasikan dua bagian tersebut secara rekursif untuk

mendapatkan rangkaian data berurutan.

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);
}
}
d. 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:

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

}
e. 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).

f. Searching

a) 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){

found = true;

else{

i = i + 1;

if (found){

*idx = i;

else{

*idx = 0;

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

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.

 KESIMPULAN

Berdasarkan uraian bahasan “jenis-jenis algoritma searching dan

sorting” dapat disimpulkan bahwa :

1. Terdapat banyak algoritma searching dan sorting yang bias

programmer gunakan sehingga dapat digunakan dalam situasi dan

kondisi masalah tertentu.

2. Pembuat algoritma baru dirasakan sangat penting Karena setiap

masalah akan memerlukan teknik sorting dan searching yang baik

dan sesuai.