Assembly Dili İle Binary Search Gerçekleştirimi

TOBB EKONOMİ VE TEKNOLOJİ
ÜNİVERSİTESİ
MÜHENDİSLİĞE GİRİŞ–100 DERSİ PROJE ÖDEVİ
2007–2008 Güz Dönemi
Öğretim Görevlisi : Prof. Dr. Ali YAZICI
Konu : Binary Search
HAZIRLAYANLAR
Alper AKSAÇ Seval ÜNVER
06110516 06110196
st06110516@etu.edu.tr st06110196@etu.edu.tr
ANKARA – 2007

2
TOBB EKONOMİ VE TEKNOLOJİ ÜNİVERSİTESİ
1. PROBLEMIN TANIMI:
Sayıların küçükten büyüğe doğru sıralı bir şekilde verildiği bir dizide istenen sayının var
olup olmadığını buluyoruz.
2. ÇÖZÜM YÖNTEMİ VE ALGORİTMASI
Binary search sıralı ve kayıt sayısı fazla veriler üzerinde kullanılan en etkin arama
algoritmasıdır. Sayıları küçükten büyüğe doğru yazdığımızı varsayalım. Bu teknikle her
seferinde listenin ortasındaki sayı ile aranan sayı karşılaştırılır. Buna göre listenin ortasındaki
sayı aradığımız ile eşitse sayıyı listede bulmuşuz demektir. Fakat aradığımız sayıdan büyük
ise listenin üst tarafı elimine edilir ya da küçükse listenin alt tarafı elimine edilir. Böylece
kalan liste tekrar ikiye bölünerek ortadaki sayıya ulaşılır ve işlem tekrarlanır. Bu stratejiyi
tekrar tekrar izleyerek tarayacağımız aralığı daraltırız ve istenen değere ulaşırız.
Binary search çoğunlukla sıralı bir listede belli bir sayıyı ararken kullanılır. Bu teknikte
indeks gibi içinde değerler listesinin bulunduğu numaralandırılmış bir bölgeyi tarar. Bu
kullanışlı bir yöntemdir çünkü indeksin verildiğinden diğer veri yapıları birleşmiş bilgi
içerecektir. Data yapılarının isim listesi, adres, telefon numarası ve daha fazla bilgiyi
içerdiğini farz edersek, örneğin birisinin telefon numarasını ararken bu numaranın kime ait
olduğunu da bulmuş oluruz. Bu bağlamda çok işlevsel olan bu yöntem sıklıkla
kullanılmaktadır. Fakat biz projemizde sadece işin mantığını kavrama amaçlı olduğu için daha
basit bir arama listesi kullandık. Bu listede sadece sayılar bulunmaktadır. Sayıların küçükten
büyüğe doğru sıralanmış olması zorunludur. Ya da bunun yerine algoritmadaki birkaç satırı
değiştirerek büyükten küçüğe doğru sıralanmış sayıları da kullanabiliriz. Listedeki eleman
sayısındaki sınırı tartışma kısmında açıkladık. Programımız hedef değere ulaşırsa çıktı olarak
“buldum”, ulaşamazsa yani listede o sayıyı bulamazsa “bulamadım!!” uyarısını verecek.
Diğer bir yandan sayıya ulaşmak için kaç kere ikiye böldüğünü hesaplayacak.
2.1. ALGORITMA
En doğru uygulama tekrar tekrar tarayarak karşılaştırmalar yapan özyineli uygulamadır.
Her seferinde taranacak kısım daralacak ve hedefe yaklaşacaktır. Bunu şu algoritmada
görebiliriz:
Binary Search (A [0...N-1], value, low, high) {
If (high < low)

3
return not found
mid = (low + high) / 2
If (A[mid] > value)
return Binary Search(A, value, low, mid-1)
Else if (A[mid] < value)
return Binary Search(A, value, mid+1, high)
Else
return mid
}
Yukarıda eylem 0 ve (n–1) değerleri arasındaki en yüksek ve en düşük değerle
sonlandırılır. Yukarıdaki kuyruk tekrarını (tail recursion) eleyebilir ve bunu tekrarlı
uygulama(iterative implementation) ile değiştirebiliriz:
Binary Search (A [0...N-1], value) {
low = 0
high = N - 1
while (low <= high) {
mid = (low + high) / 2
If (A[mid] > value)
high = mid - 1
Else if (A[mid] < value)
low = mid + 1
Else
return mid
}
return not found
}
Bu algoritmalar bizim kendi yazacağımız programın çıkış noktalarıdır. Kendi
programımızda da sayıları başta girmekteyiz. Sonra başlangıç ve bitiş noktalarını
belirlemekteyiz. Yukarıdaki algoritmada bitişin bir eksiği alınmaktadır. Oysa biz
programımızda bitişin bir fazlasını kullandık. Böylece ikiye bölümde tam olarak orta noktaya
ulaşmaktayız. Buna ek olarak da başlangıç ve bitiş değerlerine ulaşabilmekteyiz. Eğer ikiye
bölmemiz gereken sayı tek bir sayı ise çıkan buçuklu sayıyı bir küçüğüne yuvarlıyoruz. Tabi
ki bu sadece teorik bir yaklaşım, makine bunu yuvarlama diye bir kavram yapmadan
hesaplıyor.
Aşağıda Binary search akış şeması olarak gösterilmiştir:

4
2.2. ANALİZ:
Elemanları sırasıyla :
2 – 5 – 7 – 9 – 11 – 13 – 18 – 27 – 33 olarak verişmiş 9 elemanlı bir dizide 13 sayısının olup
olmadığını analiz yöntemi ile bulmaya çalışalım.
BAŞLA
N, AN, x
IB=1
IS=N
IC=(IB+IS)/2
X>A(IC)
IB=IC+1 IS=IC–1
D Y
IC=(IB+IS)/2 SON
YD
DUR
X, IC. gözdedir Sayı
Bulunamadı
IB<IS
&
X<>A(IC)
X=A(IC)
IB=Altsınır
IS=Üstsınır
IC=Ortalama
N=Eleman sayısı
AN=Eleman değeri
X=Aranılan sayı

5
Yukarıdaki tabloda görüldüğü gibi 13 sayısını toplam 3 adımda bulmuş olduk. Aradığımız
sayı ortadaki elemandan büyük ise IB’ yi, küçük ise IS’ yi değiştiriyoruz.
X>A(IC) ise X=IC+1
X<A(IC) ise X=IC–1
3. SEÇİLEN UYARLAMA DİLİ VE YAZILIMI
Uyarlama dili olarak assembly dilini kullanıyoruz. Bu dil makine diline en yakın dildir.
Bunun için de Simpsim (Simple Simulatör) adı verilen yazılımı kullanıyoruz. Bu yazılımda
kullanabileceğimiz komutlar çok sınırlıydı.
3.1. Operations
Aşağıdaki tabloda simple simulator assembly programı için kullanılan operant kodları,
operantlar ve işlevleri vardır:
OP-
CODE
OPERATION TANIM
1 load RN, [XY]
LOAD register N değerine memory’ deki XY değerini
yükler (Direct Load).
reg[N] := memory[XY]
Örnek: load R3,[0A0h]
2 load RN, XY
LOAD register N değerine XY değerini yükler
(Immediate Load).
reg[N] := XY
Örnek: load RF,10 (Bu komut registeri ile
N X IB IS IC X & A[IC]
9 13 1 9 5 X >A(IC)
9 13 6 9 7 X >A(IC)
9 13 6 6 6 X=A(IC)

6
OP-
CODE
OPERATION TANIM
ekrana(konsola) yazı yazdırılır.)
3 store RN, [XY]
STORE register’ deki N değerini memory hücrelerinde
XY adresine yazdırır (Direct Store).
memory[XY] := reg[N]
4 move RN, RM
MOVE (i.e. copy) M register’ ındaki değeri N register’
ına taşır.
reg[N] := reg[M]
Örnek: move R0,R4 (Bu komut register 4’deki değeri
register 0’a kopyalar.)
5 addi RL, RM, RN
ADD M ve N register’ larındaki değerleri toplayıp L
register’ ına yazar.(Integer Addition)
reg[L] := reg[M] + reg[N]
Örnek: addi R0,R0,R1 (Bu komut register 1 ve 0’daki
değerleri toplatıp tekrar 0’a yazar .)
6 addf RL, RM, RN
ADD M ve N register’ larındaki değerleri toplayıp L
register’ ına yazar.(Floating-point Addition)
reg[L] := reg[M] + reg[N]
Örnek: addi R0, RA, RB
7 or RL, RM, RN
OR register M ve N’ deki değerleri or’ layıp L register’
ına yazar.(Bitwise OR).
reg[L] := reg[M] OR reg[N]
8 and RL, RM, RN
AND register M ve N’ deki değerleri and’ leyip L
register’ ına yazar. (Bitwise AND).
reg[L] := reg[M] AND reg[N]
9 xor RL, RM, RN
EXCLUSIVE OR register M ve N’ deki değerleri xor’
layıp L register’ ına yazar. (Bitwise XOR).
reg[L] := reg[M] XOR reg[N]
A ror RN, M
ROTATE N register’ ındaki değeri M kez sağa kaydırır.
reg[N] := reg[N] >> M
Örnek: ror R1,2 (register 1’deki değeri 2 bit sağa
kaydırır.)

7
OP-
CODE
OPERATION TANIM
B
jmpEQ RN=R0,XY
JUMP N register’ ındaki değer 0’da kine eşit olduğu
zaman memory’ deki XY(label) adresine gider.
PC := XY if reg[N] = reg[0]
Örnek: jmpEQ R3=R0,48
Örnek: jmpEQ RB=R0,loop
jmp XY
JUMP memory’ deki XY(label) adresine gider.
(Unconditional Branch).
PC := XY
C halt HALT durmak, iptal etmek.
D load RN,[RM]
LOAD RW’ deki adresi bellekte bulup RN’ ye yazar
(Indirect Load).
reg[N] := memory[reg[M]]
E store RN,[RM]
STORE RN değerini RM’ deki adrese yazar(Indirect
Store).
memory[reg[M]] := reg[N]
F
jmpLE
RN<=R0,XY
RN R0’a eşitse veya R0’den küçükse XY ye atlar
PC := XY if reg[N] <= reg[0]
Örnek: jmpLE R3<=R0,30h
3.2. Pseudo-Operations
Simpsim assembly dili pseudo-operations da içerir:
PSEUDO-OP TANIM
db N
db M,N,…
db "string",0
Dataya N değerini girer.
Örnek: db 1,4,9,16,25,36
db "Hello, world",10,0
org addr ORIGIN: Bellekteki bir sonraki veriyi ekler.

8
4. ASSEMBLER PROGRAMI LISTESI
Aşağıda yazmış olduğumuz programın kodları metinsel olarak bulunmaktadır.
org 01
veri: db 1,2,4,7,9,12,15,23,35,36,69
org 32
sayi: db 2 ;aranılan sayı
org 60
load r1,1 ;1.terim
load r2,20 ;2.terim
load r9,[sayi] ;aratacağımız sayı
load r4,2
load r5,0ffh ;r5=-1, sabit=-1
load r6,1 ;r6=1, sabit=1
xor r4,r4,r5
addi r4,r4,r6 ;r4=-2, sabit=-2
addi r2,r2,r6
dongu:
addi r3,r2,r1 ;ra=0, sabit=0
move r8,r5
addi rd,rd,r6 ;rd bize kaç kere ikiye bölme işlemi yapıldığını veriyor
division:
addi r3,r3,r4
move r0,r3
addi r8,r8,r6
jmpEQ r4=r0, ok
jmpEQ r5=r0, ok
jmp division
ok: load r0,[r8]
jmpEQ r9=r0, EVET
jmpLE r9<=r0, kucuk
load r0,10
jmpEQ rd=r0, HAYIR
buyuk:
move r1,r8
jmp dongu
kucuk:
move r2,r8
jmp dongu
HAYIR:
load r4,karakter1
jmp yazdir
EVET:
load r4,karakter
jmp yazdir

9
yazdir:
load R5,1
load R0,0
NextChar:load RF,[R4]
addi R4,R4,R5
jmpEQ RF=R0,loop
jmp NextChar
loop: halt
karakter: db 10
db "BULDUM",10
db 0
karakter1: db 10
db "BULAMADIM!!!",10
db "Lutfen gecerli sayi giriniz",10
db 0
halt
4.1. ORNEK VERILER
Örnek olarak belleğimize 20 tane sayı girdik:
Veri: 1,3,12,14,19,23,27,46,51,57,59,60,61,71,72,73,84,81,91,100
Aradığımız sayı: 62
Bu sayıyı 1. ve 20. sayı aralığında arıyoruz.

10

11
Programı assemble yapınca karşımıza bu yukarıdaki ekran çıkıyor. Listemiz belleğe
girilmiş durumda. 20 ve daha fazla sayı içeren listeler için RE register’ına makine
kendiliğinden (33)hexadecimal sayısını atıyor. Bu yüzden bu registeri kullanmadık. RD
registeri de kaç kere bölme yapıldığını sayıyor.
4.2. Işlem basamakları:
1. Veri belleğe yazdırılır.
2. R1’e listede aratacağımız aralığın başlangıç sayısının sırası girilir. Ör: 1. sıradaki
sayıdan 20. sıradaki sayıya kadar olan aralıkta başlangıç olarak 1. girilecek.
3. R2’e listede aratacağımız aralığın son sayısının sırası girilir.
4. Aranılan sayı R9’a yazdırılır.
5. R4’e (-2), R5’e (-1), R6’a 1 girilir. Bu sayılar registerlerde “yazdır’ a” kadar sabit
olarak duracaktır.
6. R2’ye 1 eklenir.
7. R1 ve R2 toplatılıp R3e yazılır.(döngü)
8. RD’ ye 1 atılır.
9. R3’deki sayı (-2) ile toplanıp R0’a atılır.(division)

12
10. R8’e 1 eklenir.
11. Bölme işlemi R0 (-1) veya (-2) olduğunda durur. Değilse “division’ a” dönülür.
12. Bölme işlemi sonunda sonuç R8’de görülür.
13. R8’deki adres bellekte bulunur ve oradaki sayı R0’a getirilir.
14. Eğer R9 R0’a eşitse “EVET’ e” gidilerek ekrana “BULDUM” yazdırılır.
15. Eğer R9 R0’dan küçükse R8’in değeri R2’ye taşınır. Döngüye geri dönülür.
16. Eğer R9 R0’dan büyükse R8’in değeri R1’e taşınır. Döngüye geri dönülür.
17. R0’a 13 atılır. Bu sayı bölme işlemini en fazla kaç kere yapmasını istediğimizi
gösteriyor.
18. Eğer döngü sırasında RD 13’e ulaşırsa işlem durdurulur ve “HAYIR’ a” gidilir.
Buradan da ekrana “BULAMADIM!!! Lutfen gecerli sayi giriniz” yazdırılır.
Bu akış diyagramını takip edersek verdiğimiz örnekte aradığımız sayının değerler
listemizde olmadığını görürüz. Programımız 13. ikiye bölme uygulamasını da yaptıktan sonra
işlemi durdurmuş ve ekrana “bulamadım” yazdırmıştır.
Diğer bir örnekle incelersek:
Veri: 1,2,4,7,9,12,15,23,35,36,69
Aradığımız sayı: 2
Arayacağımız aralık1.ve 11. sayılar arası

13
Bu örnekte 20 den az sayıda sayı içeren bir liste kullandığımız için RE registeri boş kaldı. RD
registerinde gördüğümüz “04” bize programın 4 kere ikiye bölme işlemi yaptığını gösteriyor.
Sayımız listede ikinci sıradaydı. Programımız sayıyı bulduğu için ekrana “BULDUM” yazdı.

14
5. KURUMSAL SINIR:
Programımızda sınırlı sayıda veri içeren liste kullanmak zorundayız. Bölme işleminin
maksimum 13 kere yapılabileceği bir liste maksimum n kadar eleman içersin. Bunun için:
log2N =13 alırsak N=2^10 olacaktır. Bu da 1024 eleman eder.
Bunun teorik olarak doğru olduğunu varsayıyoruz. Çünkü bu kadar eleman içeren bir listede
arama yapmak için daha büyük bir belleğe sahip olmamız gerekir. Bellekte 32h adresine
aradığımız değeri girdiğimiz için ve 00h adresini kullanmadığımız için bu aralıkta en fazla 31
değer belleğe yazdırılır diyebiliriz.
6. SONUÇLAR VE TARTIŞMA
Yaptığımız program listeyi ikiye bölüyor ve bulduğu değeri istenilen değerle
karşılaştırıyor. Eğer bulunan orta değer istenilen sayı ile eşitse ekrana “BULDUM” çıktısını
verdi. Ama eğer bulunan orta değer istenilen sayıdan büyükse orta değer listenin üst sınırı
olarak alınıyor. Ya da bulunan orta değer istenilen sayıdan küçükse orta değer alt sınır olarak
alınıyor ve işlemler tekrarlanıyor. Bu bölme işlemlerini en fazla 10 kere yapabiliyoruz. Eğer
böyle bir sınır konmazsa program kısır döngüye giriyor.“HAYIR’ a” gidebilmesi için
programın bu kısır döngüden çıkması gerekiyor. On kez böldükten sonra sayıyı bulamadığı
için ekrana “BULAMADIM!!! Lutfen gecerli sayi giriniz” çıktısı veriyor.
Programımıza, ekrana kaç kere bölme işlemi yaptığını ve ya bulduğu sayının listede
kaçıncı sırada olduğunu yazdırmak için bir eklenti yapamıyoruz. Eğer bunu da eklersek bellek
dolduğu için program hata veriyor. (Not: Sadece 10 sayı içeren bir liste için uyarlanmıştır.)
Bu yazdığımız program aşağıdadır:
org 01
veri: db 1,2,4,7,9,12,15,23,35,36
org 32
sayi: db 2 ;aranılan sayı
org 60
load r1,1 ;1.terim
load r2,10 ;2.terim
load r9,[sayi] ;aratacağımız sayı
load r4,2
load r5,0ffh ;r5=-1, sabit=-1
load r6,1 ;r6=1, sabit=1
xor r4,r4,r5
addi r4,r4,r6 ;r4=-2, sabit=-2
addi r2,r2,r6
dongu:

15
addi r3,r2,r1 ;ra=0, sabit=0
move r8,r5
addi rd,rd,r6 ;rd bize kaç kere ikiye bölme işlemi yapıldığını veriyor
division:
addi r3,r3,r4
move r0,r3
addi r8,r8,r6
jmpEQ r4=r0, ok
jmpEQ r5=r0, ok
jmp division
ok: load r0,[r8]
jmpEQ r9=r0, EVET
jmpLE r9<=r0, kucuk
load r0,10
jmpEQ rd=r0, HAYIR
buyuk:
move r1,r8
jmp dongu
kucuk:
move r2,r8
jmp dongu
HAYIR:
load r4,karakter1
jmp yazdir
EVET:
load r0,1
jmpEQ r8=r0, A
load r0,2
jmpEQ r8=r0, B
load r0,3
jmpEQ r8=r0, C
load r0,4
jmpEQ r8=r0, D
load r0,5
jmpEQ r8=r0, E
load r0,6
jmpEQ r8=r0, F
load r0,7
jmpEQ r8=r0, G
load r0,8
jmpEQ r8=r0, H
load r0,9
jmpEQ r8=r0, K
load r0,10
jmpEQ r8=r0, L
hopla:
yazdir:
load R5,1
load R0,0
NextChar:load RF,[R4]
addi R4,R4,R5
jmpEQ RF=R0,loop

16
jmp NextChar
loop: halt
A: load R4,A1
jmp hopla
A1:
db "BULDUM",10
db "Sayınız 1.sırada",10
JMP DUR
B: load R4,B1
jmp hopla
B1:
db "BULDUM",10
JMP DUR
C: load R4,C1
jmp hopla
C1:db 10
db "BULDUM",10
db 0
JMP DUR
D: load R4,D1
jmp hopla
D1:db 10
db "BULDUM",10
db 0
halt
E: load R4,E1
jmp hopla
E1: db 10
db "BULDUM",10
db 0
halt
F: load R4,F1
jmp hopla
F1:db 10
db "BULDUM",10
db 0
halt
G: load R4,G1
jmp hopla
G1: db 10
db "BULDUM",10
db 0
halt

17
H: load R4,H1
jmp hopla
H1: db 10
db "BULDUM",10
db 0
halt
K: load R4,K1
jmp hopla
K1: db 10
db "BULDUM",10
db 0
JMP DUR
L: load R4,L1
jmp hopla
L1:db 10
db "BULDUM",10
db 0
JMP DUR
karakter1: db 10
db "BULAMADIM!!!",10
db "Lutfen gecerli sayi giriniz",10
db 0
halt
DUR: halt
Programı assembly dilinde yazma aşamasında düzensiz haliyle aşağıdaki ilk hali olan beta
sürümünü yazdık. Bu programda yaptığımız bazı düzenlemeler ile fazladan döngüye giren
kısımları çıkardık ve kısalttık.
org 01h
veri: db 1,3,4,5,8,9,10,14,15,17
org 40h
load r1,1 ;1.terimin başlangıç aralığı
load r2,10 ;2.terimin başlangıç aralığı
load r4,2
load r5,0ffh
load r6,1
load r9,3 ;aratacağımız sayı
load r0,[r2]
jmpEQ r9=r0,EVET2 ;son terimi kontrol etmek
xor r7,r5,r4
addi r7,r7,r6 ;-2 değerine elde ettik
addi re,re,r6 ;hayır için re++
addi r3,r2,r1 ;belirlediğimiz terim aralığındaki başlangıç ve bitiş
değerlerinin toplamı

18
division:
addi r3,r3,r7
move r0,r3
addi r8,r8,r6 ;bölme sonucu
jmpLE r4<=r0, division
load r0,[r8]
jmpEQ r9=r0, EVET
jmpLE r9<=r0, division4 ;aradığımız sayı küçük ise altsınır için
division4 de gidecek.
addi ra,r8,r6 ;bölme sonucuna +1
division5:
division3:
division2:
addi re,re,r6 ;hayır için re++
addi r1,ra,r2 ;alt veya üst sınır için toplama
division1: addi r1,r1,r7
move r0,r1
addi rb,rb,r6
jmpLE r4<=r0, division1 ;alt veya üst sınır için toplama
load r0,[rb]
jmpEQ r9=r0, EVET1
move rc,rb
move rd,r2
move r2,rb
load rb,0
jmpLE r9<=r0, division2 ;alt veya üst sınırda tekrar alt ve üst sınır
arama
load r0,10
jmpEQ re=r0, HAYIR ;kısır döngüye girdiği zaman işlemi sonlandırmak için
;ki buda sayıyı bulamadığını gösterir
;re de kaç kere bölme yaptığımız
yazdırılıyor
move ra,rc
move r2,rd
load rb,0
jmp division3
division4:
move r2,r8
move ra,r6
load r8,0
jmp division5
EVET2:
EVET3:
EVET1:
EVET:load R4,karakter
jmp hopla
HAYIR:load R4,karakter1
jmp hopla1

19
hopla1:
hopla: load R5,1
load R0,0
Sonraki:load RF,[R4]
addi R4,R4,R5
jmpEQ RF=R0,loop
jmp Sonraki
loop: halt
karakter: db 10
db "BULDUM",10
db 0
halt
karakter1: db 10
db "BULAMADIM",10
db "Lütfen!!!Geçerli Sayi Giriniz",10
db 0
halt

Assembly Dili İle Binary Search Gerçekleştirimi

Recommended

Recommended

More Related Content

More from Seval Çapraz

More from Seval Çapraz (12)

Assembly Dili İle Binary Search Gerçekleştirimi