Pengenalan Pohon

Semester ini saya mendapatkan matakuliah baru dan kebetulan saya tidak pernah mendapatkan ilmunya ketika saya kuliah. Alhasil saya harus benar-benar menguasai sebelum saya mengajar dikelas. Matakuliahnya sangat menarik penuh dengan logika saya sangat suka tapi cukup kewalahan mencari materi. Ok mari kita mulai..

Pohon adalah struktur data yang secara bentuk menyerupai pohon. Hanya saja berbeda dengan dunia nyata pohon tumbuh ke atas tapi di struktur dari pohonnya tumbuh ke bawah. Pohon terdiri dari serangkaian simpul (node) yang saling terhubung. Sebuah pohon merepresentasikan sebuah hirarki atau tingkatan. Contoh pohon:

  1. Pohon Struktur Organisasi

mdp

2. Daftar isi sebuah bukudaspro

Banyak istilah-istilah umum yang perlu anda ketahui:

p1

Gambar 3. Contoh Pohon

  1. Induk (Parent)
    Node yang berada di atas node lain secara langsung. Contoh dari Gambar 3, 1 merupakan parent dari 2, 3 dan 4. Contoh lain 4 merupakan parent dari 7, 8 dan 9.
  2. Anak (Child)
    Node anak adalah node yang merupakan cabang langsung dari sebuah node. Contoh 2 adalah anak dari 1.
  3. Akar (root)
    Akar adalah node yang tidak memiliki induk atau node yang paling tinggi. Jika dilihat pada Gambar 3, maka rootnya adalah 1.
  4. Daun (leaf)
    Daun adalah node yang tidak memiliki anak. Seperti : 5, 6, 3, 7, 8, dan 9.
  5. Simpul dalam (internal node)
    Simpul dalam adalah simpul yang memiliki anak minimal 1. Seperti node 1, 2 dan 4.
  6. Simpul luar (external node)
    Simpul luar adalah simpul yang paling luar atau sama saja dengan daun. Seperti: 5, 6,3,7, 8 dan 9.
  7. Level
    Level adalah tingkatan yang ditinjau dari posisi akar. akar memiliki level 0. Untuk contoh pohon dapat dilihat pada Gambar 4.
  8. Tinggi (Height)
    Ketinggian adalah level tertinggi dari suatu pohon di tambah dengan 1. Maka ketinggian pohon pada Gambar 4 adalah 4 (level tertinggi+1).

    picture1

    Gambar 4. Contoh Pohon 2

  9. Derajat
    Derajat adalah jumlah anak maksimal yang boleh dimiliki oleh node. Dari Gambar 4 node T memiliki anak terbanyak yaitu 3. Maka derajat dari pohon tersebut adalah 3.

Binary Tree

Pohon biner adalah jenis pohon yang memiliki ke khasan, yaitu jumlah anak setiap simpul maksimal dibatasi dua buah saja.

1. Node

Pada dasarnya pohon biner sama saja dengan list hanya saja koneksinya lebih dari 1. Biasanya node  tree terdiri dari 2 bagian, data dan koneksi. Pada pohon biner terdapat koneksinya adalah koneksi kiri (anak kiri) dan koneksi kanan (anak kanan).

node

   Gambar 1. Representasi Node

  • Data adalah nilai yang disimpan didalam node dan biasanya tipe datanya adalah tipe data primitif.
  • Sedangkan L adalah koneksi yang menghubungkan dengan Node sebelah kiri.
  • dan R adalah koneksi yang menghubungkan dengan Node sebelah kanan.

Ada juga Node yang memiliki 3 koneksi, yaitu kanan, kiri dan parent.

Picture1

Gambar 2. Node dengan 3 koneksi

Parent adalah koneksi yang menghubungkan Node dengan Node orang tuanya. Sehingga anaknya bisa mengetahui data orang tuanya. Berbeda dengan Gambar 1, hanya orang tua yang mengenali anak tetapi tidak sebaliknya.

2. Pohon

Sebuah pohon harus memiliki akar atau root. Root dari sebuah pohon tidak boleh lepas karena root adalah pangkal dari sebuah pohon. Jika kita mengetahui pangkal sebuah pohon maka otomatis kita bisa menngunjungi semua node pada pohon tersebut.

Jenis-Jenis Binary Tree

  1. Full Binary Tree
    Pohon biner yang semua nodenya (kecuali leaf) pasti memiliki 2 anak dan tiap subtree memiliki tinggi pohon yang sama.
    Picture2
  2. Complete Binary Tree
    Pohon biner yang mirip dengan full binary tree tetapi tiap subtree memiliki selisih ketinggian minimal 1. Contoh tinggi pohon kiri 2 dan pohon kanan 1. maka selisihnya adalah 1. Jika selisih 1 maka pohon di bawah ini dapat diseput pohon complete.
    Picture3
  3. Skewed Binary Tree
    Pohon biner yang semua nodenya hanya memiliki 1 anak dan pohonnya condong. Misal condongnya ke kiri maka semua node hanya memiliki anak kiri semua begitu juga sebaliknya.
    Picture4

 

Metode Pengurutan Gelembung

Pengurutan adalah proses mengatur sekumpulan obyek menurut urutan atau susunan tertentu. Urutan obyek tersebut dapat menaik (ascending) atau menurun (descending). Data yang telah terurut memiliki beberapa keuntungan. Selain mempercepat pencarian dari data yang terurut dapat langsung diketahui nilai maksimum dan nilai minimum. Untuk data numerik menurun nilai minum adalah elemen terakhir, dan nilai maksimum adalah elemen pertama.

Asal penamaan “Bubble Sort” diinspirasikan oleh gelembung sabun yang berada di permukaan air. Bubble short adalah metode sorting yang mudah di pahami,bila dibandingkan dengan metode sorting yang lainnya. Bubble sort mengurutkan data dengan cara membandingkan elemen sekarang dengan elemen berikutnya. Pengurutan ini seolah-olah menggeser satu persatu elemen dari kanan ke kiri. Ketika satu proses telah selesai, maka bubble sort akan mengulangi proses, demikian seterusnya. Kapan berhentinya? Bubble sort berhenti jika seluruh array telah diperiksa dan tidak ada pertukaran lagi yang bisa dilakukan, serta tercapai perurutan yang telah diinginkan.

Proses Bubble Sort
Umumunya proses pengurutan Bubble adalah pengurutan dari kanan ke kiri dimana bilangan yang terkecil ada di sebelah kiri dan bilangan terbesar adalah bilangan yang paling kanan. Setiap tahapnya selalu dimulai dari index yang paling kanan dan dibandingkan dengan sebelahnya, apakah dia lebih kecil? Jika iya maka tukarkan, jika tidak cek bilangan yang sebelumnya. Proses-proses dari Bubble sort:

1) Mulai dari elemen K= N, N-1, N-2….sampai K=2, bandingkan L[K] dengan
L[K-1]. Jika L[K]<L[K-1], maka tukarkan L[K] dengan L[K-1].
2) Mulai dari elemen K = N,N-1,…3, bandingkan L[K] dengan L[K-1]. JikaL[K]<L[K-1], tukarkan L[K] dengan L[K-1].
3) Mulai dari elemen K=N,N-1,…4. Bandingakan L[K] dengan L[K-1].Jika L[K]<L[K-1], tukarkan L[K] dengan L[K-1]. Pada akhir langkah 3, elemen L[3] berisi harga minimum ketiga, larik L[1…3] terurut, sedangkan L[4…N] belum terurut.
……..
4) Dan yang terakhir: N-1. Mulai dari elemen K=N, bandingkan L[K] dengan L[K-1]. Jika L[K]<L[K-1], tukarkan L[K] dengan L[K-1].

Contoh proses pengurutan dengan Bubble Sort:

Misal kita mempunyai sebuah array dengan nama L, dengan nilai masing-masing elemen sebagai berikut:
Index 1 2 3 4 5
Nilai 78 13 67 2 9

Hal pertama yang akan kita lakukan adalah menentukan nilai elemen yang pertama yang harus dibandingkan (K) karena pengurutan bubble memulai dari kanan ke kiri maka nilai K adalah index yang paling kanan yaitu 5.

Indek 1:

K=5:
Kita akan membandingkan L[5] dengan L[4], karena L[5]!<L[4] maka tidak terjadi pertukaran.
78 13 67 2 9

K=4:
Bandingkan L[4] denganL [3], karenaL[4]<L[3]. Maka tukarkan L[4] denganL[3].

78 13 2 67 9
78 13 67 2 9

K=3:
Bandingkan L[3] dengan L[2], karena L[3]<L[2], maka tukarkan L[3] dengan L[2].
78 2 13 67 9

78 13 2 67 9

K=2:
Bandingkan kembali L[2] dengan L[1], karena L[2]<L[1] maka tukarkan L[2] dengan L[1].
78 2 13 67 9
2 78 13 67 9


Karena K hanya sampai i+1 maka nilai K pada tahap ini hanya sampai K=2.
Dan hasil akhir dari tahapan ini adalah:
2 78 13 67 9

Indek 2:
K=5

Seperti indeks 1 kita akan membandingkan L[5] denganL[4]. Kerena L[5]<L[4] maka L[5] ditukarkan dengan L[4].
2 78 13 67 9
2 78 13 9 67


K=4
Selanjutnya kita bandingkan lagi L[4] dengan [3].Karena L[4]<L[3] maka tukarkan nilai L[4] dengan nilai L[3].
2 78 13 9 67
2 78 9 13 67


K=3:
Bandingkan kembali L[3] dengan L[2], karena L[3]<L[2] maka tukarkan L[3] dengan L[2].
2 9 78 13 67
2 78 9 13 67

Tahap 4

2 9 78 13 67

K=5:
Bandingkan L[5] dengan L[4], karena L[5]!<L[4] maka tidak terjadi pertukaran.
2 9 78 13 67

K=4:
Bandingkan kembali L[4] dengan L[3], karena L[4]<L[3] maka tukarkan L[4] dengan L[3].
2 9 78 13 67
2 9 13 78 67

Hasil dari tahap ini adalah:
2 9 13 78 67

Indeks 4

K=5
Pada indeks 4 ini kita hanya bisa membandingkan L[5] dengan L[4]. Karena L[5]<L[4] maka tukarkan L[5] dengan L[4].
2 9 13 67 78

2 9 13 78 67

Hasil pengurutan adalah:
2 9 13 67 78

Kesimpulan
Pengurutan Bubble Sort merupakan pengurutan yang tidak efisien, karena membutuhkan operasi pertukaran pada setiap langkah. Sehingga jika ukuran larik yang besar, pengurutan dengan metode ini membutuhkan waktu yang relatif lebih lama dibandingkan dengan metode pengurutan yang lain sehingga tidak direkomendasikan untuk dipakai, anmun metode ini cukup sederhana untuk dipahami.
procedure UrutGelembung(input/output L: Larik; input N : integer)
Deklarasi:
I : integer {pencacah untuk jumlah langkah}
K : integer {pencacah untuk pengapungan pada setiap langkah}
Temp : integer {peubah bantu untuk pertukaran}
Algoritma
for I ← 1 to N-1 do
for K ← N downto I+1 do
if L[K] < L[K-1] then {pertukarkan L[K] dengan L[K-1]}
Temp ← L[K]
L[K] ← L[K-1]
L[K-1] ← Temp
endif
endfor
endfor

Pemrosesan Kata dengan List (Word Processing with List)

Sebenarnya ini adalah tugas besar yang pernah saya berikan kepada mahasiswa saya. Karena batas pengumpulan sudah lama lewat maka rasanya tidak apa-apa jika saya publish solusinya.

Pada dasarnya kali ini saya akan membahas bagaimana membuat pemrosesan text di C++. Yang di maksud dengan  pemrosesan disini adalah menghitung banyak kata dari paragraf yang kita input dan menghitung ada berapa banyak sebuah kata muncul dalam satu paragraf. Binggung?? Baiklah saya berikan contoh :

Misal ada sebuah paragraf :

Pada hari minggu saya bersama keluarga akan berlibur ke sebuah pulau di kepualan Riau. 
Saya sudah menyiapkan semua kebutuhan sebelum kami pergi.

Dari paragraf di atas dapat kita hitung :

Jumlah kata : 22 kata
Pada : 1            hari : 1        minggu : 1        saya : 2

dan seterusnya akan dihitung untuk semua kata.

Saya rasa setelah melihat contoh diatas sudah lebih jelas gambaran aplikasi yang akan di banggun. Bahasa yang saya gunakan disini adalah bahasa C++, karena ini menggunakan Linked List. Kalau menggunakan bahasa pemrogram berorientasi objek tentu akan lebih mudah. Baiklah sebelum membuat aplikasi ini ada baiknya kita list terlebih dahulu apa yang harus dilakukan.
1. Tentu pertama adalah bagaimana kita bisa menginput sebuah paragraf di C++.
2. Kita salin semua paragraf ke dalam sebuah list.
3. Dari kalimat yang telah diinput, buang semua tanda baca.
4. Setelah dibuang semua tanda baca sekarang kita potong semua elemen list per kata simpan kedalam nested list dan hilangkan tanda spasi.
5. Menghitung kemunculan semua kata.
6. Tampilkan Jumlah semua kata dan masing-masing total.

Tahapan diatas memang terlalu berbelit, tapi kita harus menginggat kembali bahwa ini ditujukan untuk mahasiswa yang baru menggenal Senarai dan Struktur Data.

Baiklah mari kita mulai :
Langkah 1. Langkap pertama adalah input paragraf, pada dasarnya ini sanggat sederhana yaitu cukup membuat kode program yang bisa menerima inputan string.

string Tempparagraf;
cout<<"Input Paragraf :\n";getline(cin,Tempparagraf);

Langkah 2.
Kita sudah bisa menginput sebuah string yang berfungsi menampung paragraf kita. Sekarang saatnya untuk memotong string menjadi sekumpulan karakter. Sekaligus kita akan membuang semua tanda baca yang di masukkan kecuali spasi. Oh iya hampir lupa, angka juga akan dihapus karena kita hanya menghitung kemunculan suatu kata. Sebelum kita potong string menjadi sekumpulan karakter, kita sebaiknya menyiapkan sebuah list yang terlebih dahulu.

#define info(P) P->info
#define next(P) P->next
#define first(L) (L).first
typedef struct tElement *address;
typedef struct tElement{
    char info;
    address next;
}element;

typedef struct{
    address first;
}List;

Setalah list sudah siap sekarang kita salin isi string TempParagraf ke dalam list.

void CreateList(List *L){
    first(*L)=NULL;
}
address alokasi(char x){
    address P;
    P=(address)malloc(sizeof(element));
    if(P!=NULL){
        info(P)=x;
        next(P)=NULL;
    }
    return P;
}
void insertFirst(List *L, address Temp){
    Temp->next=first(*L);
    first(*L)=Temp;
}
void insertAfter(List *L,address prec, address x){
    x->next=prec->next;
    prec->next=x;
}
int IsEmpty(List L){
    if(first(L)==NULL)
        return 0;
    else
        return 1;
}
void insert(List *L, char x){
    address Temp;
    Temp=alokasi(x);
    if(IsEmpty(*L)==NULL)
        insertFirst(&(*L),Temp);
    else{
        address last=first(*L);
        while (last->next!=NULL){
            last=last->next;
        }
        insertAfter(&(*L),last,Temp);
    }
}

Sedangkan di void main kita cukup menulis :

List C;    
CreateList(&C);
address T=first(C);
for(int i=0; i<Tempparagraf.size(); i++){
        insert(&C,Tempparagraf[i]);
}
Tampil(C);

Jika telah kalian jalankan hasil dari potongan program ini adalah kita sudah berhasil menyalin semua huruf ke dalam sebuah list.

Langkah 3.

Setelah disalin sekarang saatnya kita menghapus tanda baca dan bilangan yang ada di dalam list. Untuk menghapus elemen list kita harus memiliki method untuk menghapus elemen baik elemen pertama, elemen di tenggah atau elemen yang terkahir. Tetapi untuk kasus masalah ini kita hanya membutuhkan delete after karena dalam bahasa indonesia yang benar tidak boleh ada tanda baca di awal paragraf. Untuk itu berikut kode untuk menghapus elemen list after adalah.

void DeleteAfter(address prev){
    address del=prev->next;
    prev->next=del->next;
    del->next=NULL;
}

Setelah method delete after sekarang saatnya membuat method untuk menghapus tanda baca.

void DeleteTandaBaca(List *L){
    if(first(*L)!=NULL){
        address temp=first(*L)->next;
        address prev=first(*L);
        do{
            if((temp->info<65 || temp->info>93 )&&( temp->info<97 || temp->info>125)&& (temp->info!=32)){
                prev->next=temp->next;
                temp->next=NULL;
                temp=NULL;
                temp=prev->next;
            }
            else{
                prev=temp;
                temp=temp->next;
            }
        }while(temp->next!=NULL);
        if((temp->info<65 || temp->info>93 )&&( temp->info<97 || temp->info>125)&& (temp->info!=32)){
                prev->next=temp->next;
                temp->next=NULL;
                temp=NULL;
                temp=prev->next;
        }
    }
}

Langkah 4.
Setelah dibuang semua tanda baca sekarang kita potong semua elemen list per kata simpan kedalam list dalam list dan hilangkan tanda spasi. untuk itu kita harus memiliki tipe data baru yaitu list dalam list.

typedef struct LList{
    List Info;
    LList *next;
};

LList *LinkList;

Pada dasarnya list dalam list adalah list biasa tetapi info dari list tersebut adalah sebuah. Binggung kan?? Kira-kira begitulah silahkan diperluas maknanya.. Nah sekarang bagaimana menyalin list yang sudah kita buat ke dalam list dalam list. Logikanya satu elemen list dalam list (yang saya beri nama Linklist) adalah sejumlah elemen dari list C. Contoh : isi list C :

S a y a p e r g i

Sekarang bagaimana menyalinnya kedalam Linklist menjadi seperti ini :

Dari gambar diatas pemotongan kata dilakukan jika kita menemukan spasi. Brikut cara memotong semua listnya.

void Salin(List L){
    LinkList=NULL;
    List temp;
    first(temp)=NULL;
    address elemenL=first(L);
    LList *LastLinkedList=new LList;
    LastLinkedList=NULL;
    LastLinkedList=LinkList;
    do{
        if(elemenL->info!=32)
            insert(&temp,elemenL->info);
        if(elemenL->info==32 ||elemenL->next->next==NULL){
            if(elemenL->next->next==NULL)
                insert(&temp,elemenL->next->info);
            LList *NewLList= new LList;
            NewLList->Info=temp;
            NewLList->next=NULL;
            first(temp)=NULL;
            Tampil(NewLList->Info);
            if(LastLinkedList==NULL){
                LinkList=NewLList;
                LinkList->next=NULL;
                LastLinkedList=LinkList;
            }else {
                NewLList->next=LastLinkedList->next;
                LastLinkedList->next=NewLList;
                LastLinkedList=LastLinkedList->next;
            }
        }
        elemenL=elemenL->next;
    }while(elemenL->next!=NULL);
}

Langkah 5 dan 6.

Menghitung kemunculan semua kata. untuk menghitung kemunculan kata tentu kita membutuhkan method untuk membandingkan 2 buah kata, apakah dua kata tersebut sama atau tidak. Berikut adalah method untuk pembandingan

int Kompare(List A, List B){
    address a=first(A);
    address b=first(B);
    int k=1;
    do{
        if(a->info!=b->info){
            k=0;
        }
        //cout<<"\na : "<<a->info<<" b:"<<b->info;
        a=a->next;b=b->next;
    }while(k!=0 && a->next!=NULL);
    return k;
}

Sesudah dibandingkan sekarang kita hitung kemunculan setiap kata dan sudah langsung menampilkan hasil dari perhitungan setiap kata.

void Hitung(){
    List A,B;
    first(A)=NULL;first(B)=NULL;
    LList *Temp=new LList;
    cout<<"\nCek:\n";
    CetakLL();
    LList *Temp2=new LList;
    Temp2=LinkList;
    do{
        cout<<"\nkata: ";
        Tampil(Temp2->Info);
        Temp=Temp2;
        A=Temp2->Info;
        int hasil=1;
        do{
            B=Temp->next->Info;
            int t=Kompare(A,B);
            hasil+=t;
            if(t==1){
                LList *Delete=NULL;
                Delete=Temp->next;
                Temp->next=Delete->next;
                Delete->next=NULL;
            }else
                Temp=Temp->next;
        }while(Temp->next!=NULL);
        Temp2=Temp2->next;
        cout<<"Hasil :"<<hasil;
        if(Temp2->next==NULL){
            Tampil(Temp2->Info);
            cout<<"Hasil :"<<1;
        }
    }while(Temp2->next!=NULL);
}

Selesai…
Semoga bisa menjadi bahan untuk anda yang sedang mendalami tentang list dan yang sedang belajar tentang struktur data. Semoga membantu.. 🙂

Pencarian dengan Algoritma Binary Search

Pencarian bagidua atau pencarian biner adalah metode pencarian yang diterapkan pada sekumpulan data yang sudah terurut (terurut menaik atau terurut menurun). Data yang terurut syarat mutlak penerapan algoritma ini. Salah satu keuntungan data terurut adalah memudahkan pencarian, dalam hal ini pencarian bagidua.

Misalkan indeks kiri adalah Ia dan indeks kanan adalah Ib. Kondisi awal Ia=1 dan Ib = N.
Langkah 1. Bagi dua elemen larik pada elemen tengah. Elemen tengah adalah elemen dengan indeks k = (Ia+Ib) div 2
(elemen tengah , L[k], membagi larik menjadi dua bagian, yaitu bagian kiri L[Ia..k-1] dan bagian kanan L[K+1..Ib])

Langkah 2. Periksa apakah L[k] = X.
Jika L[k] = X, pencarian dihentikan sebab X sudah ditemukan. Tetapi, jika L[k] ≠ X, harus ditentukan apakah pencarian akan dilakukan di larik bagian kiri atau di bagian kanan. Jika L[k] < X, maka pencarian dilakukan pada bagian kiri. Sebaliknya, jika L[k] > X, pencarian dilakukan pada larik bagian kanan.
Langkah 3. Ulangi langkah 1 sampai X ditemukan atau Ia > Ib (ukuran larik sudah nol).

Procedure Bagidua(input L: Larik, input N:integer, input X: integer, output IX:integer)
Algoritma
Ia <-N
Ib <-1
ketemu <-false
while (not ketemu) and (Ib > Ia) do
k <-(Ia + Ib) div 2
if (L[k] = X) then
ketemu= true
else
if (L[k] > X) then
Ia <-k
else
Ib <-k+1
endif
endif
endwhile
If (ketemu = true) then
IX <-k
else
IX <-0
endif

Contoh :
Diketehui sebuah senarai belum terurut dan bilangan yang akan dicari adalah 2 :

2 35 7 4 6 1 9 4 23 25

Penyelesaian :

1. Urutkan terlebih dahulu semua bilangan, boleh terurut menaik atau terurut menurun. Kali ini saya akan menggunakan terurut menaik sehingga diperoleh array sebagai berikut dan kemudian saya tambah dengan keterangan urutan di baris bawah.

Nilai 1 2 4 4 6 7 9 23 25 35
Indeks 1 (Ib) 2 3 4 5 6 7 8 9 10 (Ia)

2. Tentukan Indek atas (Ia) dan indek bawah (Ib). Ia adalah nilai indek terbesar dari array yaitu 10. Sedangkan Ib indek terkecik dari array yaitu 1. dan kita tetapkan bahwa saat ini ketemu=tidak ketemu.
3. Cek apakah saat ini ketemu != ketemu dan Ib < dari Ia? Jika iya maka buka elemen ke-k, dimana k adalah Ia+Ib/2 = 10+1/2= 5 (Biasanya pembulatan kebawah).
4. Sekarang periksa elemen ke-5 apakah sama dengan 2 (bilangan yang dicari)? Ternyata bukan, elemen ke-5 adalah 6.
5. Karena bukan maka periksa apakah nilai elemen ke-5 > dari 2?? Jika iya maka nilai Ia akan diubah menjadi k atau sama saja dengan Ia=k=5. Sehingga area yang dicari menjadi lebih sempit.

Nilai 1 2 4 4 6
Indeks 1 (Ib) 2 3 4 5 (Ia)

6. Cek apakah saat ini ketemu != ketemu dan Ib < dari Ia? Jika iya maka buka elemen ke-k, dimana k adalah Ia+Ib/2 = 1+5/2= 3.
7. periksa elemen ke-3 apakah sama dengan 2 (bilangan yang dicari)? Ternyata bukan, elemen ke-3 adalah 4.
8. Karena bukan maka periksa apakah nilai elemen ke-3 > dari 2?? Jika iya maka nilai Ia akan diubah menjadi  k atau sama saja dengan Ia=k=3.

Nilai 1 2 4
Indeks 1 (Ib) 2 3 (Ib)

9. Cek apakah saat ini ketemu != ketemu dan Ib < dari Ia? Jika iya maka buka elemen ke-k, dimana k adalah Ia+Ib/2 = 1+3/2= 2.
10. periksa elemen ke-2 apakah sama dengan 2 (bilangan yang dicari)? Ternyata benar. Jika benar ketemu =ketemu.
11. Cek apakah saat ini ketemu != ketemu dan Ib < dari Ia? tidak! ketemu=ketemu maka perlulangan berhenti.

Jika dilihat kembali dengan binary search elemen yang diperiksa hanya elemen ke 5, 3 dan 2. dengan tiga langkah elemen yang dicari langsung ketemu.

%d bloggers like this: