Algoritmalarbook

2011 [email protected] 1

Sakarya Üniversitesi Bilgisayar Mühendisliği

Algoritmalar ve Programlama I Ders Notları

ALGORİTMA VE

PROGRAMLAMAYA GİRİŞ I

Yazar:

Doç.Dr. Cemil Öz Sakarya Üniversitesi

Sakarya 2011




Önsöz

Bir problemin çözümü için program geliştirme ve yazma çok önemli bir aşamadır.

Programlama, öğrenmeye başlayanlar için büyük bir adımdır. Bu adımın doğru atılması,

kişinin hızlı öğrenmesini, programlamayı sevmesini ve daha verimli ve özgün program

yazmasını sağlayacaktır.

Program yazımını öğrenecek kişilerin doğru adımı atarak öncelikle çözülecek problemlerin

algoritmalarının nasıl tasarlanacağını öğrenmeleri gerekir. Programın algoritması

hazırlanabiliyorsa, bilgisayarda bu problemin çözümü yapılmış demektir. Tasarlanan

algoritma, bütün programlama dillerinde yazılmış sayılır. Kodlama aşamasında bir

programlama dilinin komutları kullanılarak gerçekleştirilir. Günümüzde, yüzlerce derleyici,

yani programlama dili vardır. Bu programlama dillerinin komutları kullanılarak algoritma

kolaylıkla programrama dönüştürülebilir.

Bu kitabın amacı, çok sayıda örnek ile algoritma geliştirme mantığının verilmesidir. Bir

programlama dili öğretmek amacında değildir. Ancak geliştirilen algoritmaların programa

dönüştürlmesinde c/c++ programlama dili kullanılmıştır. Bu dan dolayı ağırlıklı olarak c

programlama dili komutları ve programlama dili de anlatılmaktadır.

c/c++ programlama dilleri, gerçek zamanlı programlama sistemleri, gömülü sitemler, oyun

programlama vb amaçla kullanılan en yaygın dillerdir. Belirtilen konularda yıllardır

kullanıldığından dolayı, programlama esnasında geçmişten gelen yaygın hazır sürücüler ve

kütüphanelerle kolaylıkla yazılım geliştirilmektedir.

Bu kitap, Algoritma ve programlamaya Giriş I dersinde izlenecek temel kitap olarak

düzenlenmiştir. Dolayıs ile öncelikli kitlesi programlama öğrenmeye başlayan öğrencilerdir.

Kitabın, okuyuculara faydalı olması dileği ile

Doç.Dr. Cemil Öz




DERSİN AMACI

Bu dersin amacı, bilgisayar programlaması konusuna bir giriş yapmak, programlama

ile ilgili genel kavramları ortaya koymak, algoritma kavramı, algoritmaların nasıl

oluşturulacağı ve yapısal programlama konusuna değinmektir.

Dersin içerisinde ayrıca yapısal özellikleri ve güçlü olanakları ile her programcının

mutlaka bilmesi gereken bir dil olan C/C++ programlama dilinin temel özellikleri

algoritma kavramı ile ilişkili olarak ortaya konulacaktır. Ayrıca çeşitli konularda

algoritma örnekleri verilecektir. Böylece daha sonraki derslerde detaylı olarak verilen

C++, C#, Java# programa dilleri ve diğer temel yazılım dersleri için bir başlangıç

oluşturulmaktadır.

FAYDALANILABİLECEK KAYNAK KİTAPLAR

1. Soner Çelikkol, Programlamaya Giriş ve Algoritmalar, Academic Book Publishing,

2007, Trabzon.

2. Vasif V. Nabiyev, Teoriden Uygulamalara Algoritmalar, Seçkin Yayıncılık, 2007,

Ankara.

3. Fahri Vatansever, İlere Programa Uygulamaları, Seçkin Yayıncılık, 2006, Ankara.

4. Sefer Kurnaz, Veri Yapıları ve Algoritma Temelleri, Papatya Yayıncılık, 2004,

İstanbul.

5. Rifat Çölkesen, Programlama Sanatı Algoritmalar C Dili Uygulaması, Papatya

Yayıncılık, 2004, İstanbul.

6. Chris H. Pappas, William H. Murray (Çeviri: Kadir Ertürk), C/C++ Programcının

Rehberi, Sistem Yayıncılık, 2003, Ankara.

7. Rifat Çölkesen, İşte C Programlama Dili, Papatya Yayıncılık, 2003, İstanbul.

8. Fahri Vatansever, Algoritma Geliştirme ve Programlamaya Giriş, Seçkin Yayıncılık,

2002, Ankara.

9. Mustafa Dikici, Emin Öztekin, Nemci Dege, Pascal Yapısal Programlama, Nesnelerle

Programlama ve Turbo Vision, Beta Basım Yayım Dağıtım 1998, İstanbul.

10. Mürşit Eskicioğlu, Pascal ile Yapısal Programlama, Evrim Basım Yayım Dağıtım,

1988, İstanbul.

11. Taner Derbentli, Programlama ve Fortran 77, Seç Kitap Dağıtım, 1988, İstanbul.




1. ALGORİTMA KAVRAMI

Algoritma, bir problem sınıfının sistemli çözümü için; sıralanmış, belirsizlik

taşımayan, işlenebilir, sonlu, işlem adımları kümesidir.

Algoritma, sayıları kolay ve doğru tanımlama sanattır. Bir işlem dizisinin sonucunu

elde etmek için, çok iyi tanımlanmış, sonlu sayıdaki işlem cümlelerinin bütünüdür.

Bilgisayar programlamasının temel adımı olan bilgisayarın işleyişine uygun çözüm

modelini kurmada bu güne kadar uygulanan yaklaşım çözüm algoritması kurma

yöntemidir.

Algoritma yaklaşımı, 9. yüzyılda yaşamış Türk-İslam matematikçi ve astronomu

Harzemli Mehmet’in ikinci derece denklemin kolayca çözümü için geliştirdiği çözüm

yönteminin genelleştirilmiş şeklidir ve algoritma sözcüğü onun adından türemiştir.

Bilgisayarlar düşünemez. Bu sebeple bilgisayarların istenen amaçlara uygun biçimde

kullanılabilmesi için programlanması gerekmektedir.

Programlama, bir işlemin bilgisayarın anlayabileceği bir biçime dönüştürülmesi

işlemidir.

Bir programın amaca uygun olarak çalışabilmesi için, belirli aşamaları yerine getirmek

gerekmektedir;

1. ANALİZ: Problem analiz edilir ve çözümlenir.

2. TASARIM: Yapılan çözümlemeye göre algoritma tasarımı/akış diyagramı

oluşturulur. Doğruluğunun mantıksal sınaması yapılır.

3. KODLAMA: Oluşturulan algoritma/akış diyagramı bir programlama dili ile

yazılır (kodlanır).

4. DERLEME: Program derlenir ve çalıştırılır. Yazım hataları varsa düzeltilir.

5. TEST: Program istenilen sonuçları üretmiyor ise 1. adıma dönülür ve problem

çözümlenmesi ve algoritma/akış diyagramı gözden geçirilir ve revize edilir.

6. DOKÜMANTASYON: Programın dokümantasyonu oluşturulur.

Problem analizi ve çözümlemesi, problemin tanımlanması, problemin giriş bilgileri ve

sonuca ulaşmak için bu bilgiler üzerinde yapılması gereken işlemlerin ayrıntılı olarak

belirlenmesidir.

Algoritma, bir problemin çözümü için yapılması gereken işlemlerin gereken sırada,

adım, adım ve basit deyimlerle yazılmış halidir.




Akış diyagramı, algoritmaların özel geometrik şekiller ile gösterilmesidir.

Algoritmaların ifade edilmesinde akış diyagramlarının yanı sıra, konuşma dili ile

programlama dili arasında, sözde kod (pseudo-code) adı verilen bir araç kullanılır.

Sözde kod, programlar gibi derlenmez ve işlenmez.

Her programcı kendi sözde kodunu geliştirebilir . Fakat kişisel sözde kodlar başkaları

tarafından anlaşılabilir bir biçimde açık olmalıdır.

Derleme, bir programlama dili ile yazılan kodların işletilebilmesi için makine diline

çevrilmesidir.

Makine dili, bir bilgisayarın anlayabileceği tek dildir. Makine dili ile yazılan

programlar yalnızca 0 ve 1’ lerden oluşur. Bu dille program yazabilmek için CPU’nun

iç yapısını bilmek gerekir. Makine dilinde programlama çok karmaşık olduğundan

makine dili kodları simgesel (assembly) dili ile ifade edilir.

Simgesel (assembly) dillerde,0 ve 1’ ler yerine bazı sözcükler ve simgeler kullanılır.

Bellek, üzerine bilgilerin yazılıp silinebileceği hücrelerden oluşur. Her hücrenin

sayısal bir adresi vardır. Bu hücrelere çoğu kez sözcük (word) adı verilir.

Programlarda yapılan işlemler bellek hücrelerinde saklanan veriler üzerinde yapılır.

Örnek:

1. 100 ile 101 numaralı hücrelerdeki bilgileri topla, sonucu 102 numaralı hücreye

yaz.

2. 100, 101 ve 102 numaralı hücrelerdeki bilgileri kağıda yaz.

3. Dur.




Daha uzun ve karmaşık problemlerde hangi bilginin hangi hücrede bulunduğunun

çetelesinin tutulmasının programcıya büyük bir yük getireceği açıktır.

Bu nedenle bütün programlama dillerinde hücrelerin sembolik adresleri olan değişken

kullanılır.

Değişken aynı zamanda o adreste bulunan bilginin adıdır.

Yukarında verilen işlem değişkenler ve aritmetik işaretler kullanılarak aşağıdaki

şekilde yazılabilir;

1. Z=X+Y.

2. X,Y,Z ‘yi yaz.

3. Dur.

Değişken kullanımı program yazımını kolaylaştırır. İki program karşılaştırılırsa X, Y,

Z’ nin sırası ile 100, 101, 102 numaralı hücrelerdeki bilgileri temsil ettiği görülebilir.

Fakat programcı açısından X bilgisinin belleğin hangi adresinde yerleştirildiğinin

bilinmesi gerekmez.

1.1. Algoritmanın özellikleri

Algoritma kurduktan sonra bir programlama dilinde yazılması o dilin deyim yapılarını,

kurallarını ve kullanılacak derleyiciyi bilmeyi gerektirir. Bu beceri birkaç aylık bir

çalışma sonunda elde edilebilir.

Algoritmanın kurulması bir çözümleme işidir. Programcının belirli bir konudaki

bilgisine ve algoritma kurma deneyimine bağlıdır. Bu nedenle algoritma kurma

becerisinin kazanılması çok daha uzun bir çalışma ve zaman gerektirir.

Algoritma kurma becerisi bir programa dilini kullanmaktaki rahatlık ve ustalıkla da

doğru orantılıdır.

Kullanılan programlama dili algoritmayı biçimsel açıdan etkiler.

Bir algoritmanın sahip olması gereken bazı özellikler vardır. Bunların bir kısmı

aşağıda verilmiştir ve bunlar daha da artırılabilir;

o Bilgisayarlar düşünemez. Bu yüzden algoritmanın her adımı anlaşılır, basit ve

kesin bir biçimde ifade edilmiş olmalıdır. Yorum gerektirmemeli ve belirsiz

ifadelere sahip olmamalıdır.

o Algoritma etkin olmalıdır. Algoritmada gereksiz tekrarlar bulunmamalıdır.

Algoritmalar yapısal ve modüler olmalı ve yazılan bir algoritma daha sonra

ihtiyaç duyulduğunda başka algoritmalar tarafından da kullanılabilmelidir.

o Algoritmanın sonlu sayıda yürütülebilir adımı olmalıdır.




o Algoritmanın girdi ve çıktısı olmalıdır.

1.2. Örnek algoritmalar

Örnek alg. 1; klavyeden girilen iki sayının toplamını bulup sonucu ekrana yazdıran bir

algoritmanın tasarlanması.

Bilgisayar mantığı ile baktığımızda sıralı bir işlem vardır. Yani her hangi bir karşılaştırma

durumu ve buna bağlı farklı işlemlerden biri seçilmemektedir.

Algoritma sözde kodlar ile ifade edildiğinde aşağıdaki şekilde yazılabilir;

Adım 1: Başla

Adım 2: Oku (a) /* sayıyı a değişkenine oku */

Adım 3: Oku (b) /* sayıyı b değişkenine oku */

Adım 4: c=a+b /* a sayısı ile b sayısını topla ve c ye ata */

Adım 5: Yaz (c) /* hesaplanan sonucu (c) ekrana yaz */

Adım 6: Dur /* programı sonlandır */

Örnek alg. 2: Bir kenarı klavyeden girilen karenin alanını hesaplayan ve ekrana yazdıran bir

algoritmanın tasarlanması.Bu örnekte de sıralı bir işlem vardır.

Adım 1: Başla

Adım 2: Oku (a) /* Karenin bir kenarını a değişkenine oku */

Adım 3: Kare_alan=a*b /* Karenin alanını hesapla */

Adım 5: Yaz (Kare_alan) /* hesaplanan sonucu (Kare_alan) ekrana yaz */


Örnek alg. 3: İkinci dereceden katsayıları bilinen bir fonksiyonun, klavyeden girilen x değeri

için alacağı değeri hesaplayıp sonucu ekrana yazdıran bir algoritma tasarlayalım. Bu örnekte

de sıralı bir işlem vardır.

İkinci dereceden denklemimiz şu şekilde olsun

F(x)=x^2+3x+4

Fonksiyonun x in -100 ile 100 arasındaki 20 artım ile çizilmiş grafiği şekil de verilmiştir. Bu

algoritmada sadece girilen bir x değeri için bir hesap yapılacak ve sonlanacağından dolayı

sıralı bir işlem yapılmalıdır.




Adım 1: Başla

Adım 2: Oku (x) /* x değerini x değişkenine oku */

Adım 3: fx=x*x+2*x+4 /* fonksiyonun x için değerini hesapla */

Adım 5: Yaz (fx ) /* hesaplanan sonucu (fx) ekrana yaz */


Örnek alg. 4: Örnek 3 de verilen problemde katsayıları belli bir İkinci dereceden denklemim

hesaplanması istenmiş idi, eğer katsayılarıda klavyeden girilecek ise ozaman algoritma

aşağıdaki şekilde düzenlenebilir


F(x)=a*x^2+b*x+c

Olsun

Adım 1: Başla

Adım 2: Oku (a) /* a katsayısını a değişkenine oku */

Adım 3: oku(b) /* b katsayısını b değişkenine oku */

Adım 4: Oku (a) /* c katsayısını c değişkenine oku */

Adım 5: Oku (x) /* x değişken değerini x değişkenine oku */

Adim 6: fx=a*x*x+b*x+c /* fonksiyonun değerini hesapla */

Adım 7 Yaz (fx) /* hesaplanan sonucu (fx) ekrana yaz */


Örnek alg. 5: Bir öğrencinin dönem içerisindeki ve dönem sonundaki notlarını klavyeden

okuyan, Yıliçi ve Başarı notunu bilinen katsayılara göre hesaplayan algoritmayı tasarlayın.

Öğrencilerin notlarını gösteren liste genelde şekil de verilen tablodakine benzerdir.

Öğrencinin Vize, kısa sınav 1, kısa sınav 2 ve ödev notu belli oranlarda alınarak yıl içi başarı

notu bulunur. Final notunun belirli bir yüzdesi ile yıl içi notunun %100’e tamamlanacak

yüzdelik oranı ile başarı puanı bulunur. Örneğin

0

2000

4000

6000

8000

10000

12000

-150 -100 -50 0 50 100 150

f(x)

f(x)




Yıl içine etki yüzdeleri

Vizenin %60 ‘ı,

Kısa sınav 1’ in %10,


Ödev notu’nun %20,

Başarı Notu

Yıliçi Nounun %50,

Final Notunun %50

Olsun

Bir öğrencinin notunu hesaplayacak şekilde algoritmayı belirtilen katsayılar için

gerçekleştirecek olursak

Adım 1: Başla

Adım 2: Oku (Ogr_Adi) /* Öğrenci adını, Ogr_Adi değişkenine oku */

Adım 3: Oku(Ogr_No) /* Öğrencinin no’nu, Ogr_No değişkenine oku */

Adım 4: Oku (Vize) /* Vize notunu, Vize değişkenine oku */

Adım 5: Oku (K1) /* Kısa sınav 1 notunu, K1 değişkenine oku */


Adım 7: Oku (Odev) /* Ödev notunu, Odev değişkenine oku */

Adım 8: Oku (final) /* final notunu, final değişkenine oku */

Adım 9: Yilici=0,60*Vize+0,1*K1+0,1*K2+0,2*Odev /* yıl içi notunu hesapla,

Yilici değişkenine ata */

Adim 10:Basari=0,5*Yilici+0,5*final /* başarı notunu hesapla, Basari değişkenine ata */

Adım 11:Yaz (Basari) /* hesaplanan başarı notunu ekrana yaz */


Örnek alg. 6: örnek algoritma 5 deki problemde, sınavların etki oranları sabit kabul edildi. Bu

programların esnekliğini bozacaktır. Katsayı değiştirildiğinde algoritmanın ve programında

değişmesini gerektirecektir. Algoritmayı yenileyeek olursak.

Adım 1: Başla

Adim 2: Vo=0,5, K1o=0,1,K2o=0,1,Oo=0,2 /* sınav oranlarını ata*/

Adim 3: Yilicio=0,5,Fo=0,5 /* genel başarı için yil içi ve final oranları */











Adım 11: Yilici=Vo*Vize+K1o*K1+K2o*K2+Oo*Odev /* yıl içi notunu hesapla,


Adim 12:Basari=Yilicio*Yilici+Fo*final /* başarı notunu hesapla, Basari değişkenine ata */



Bu algoritmada katsayılar değişkenlere atandı ve istenildiğinde değişken değerleri

değiştirilerek program tekrar çalıştırılabilir. Ancak hala program esnek değil. Bu esneklik

ancak bu değerler klavyeden okunduğunda oluşacaktır.



değişmesini gerektirecektir. Algoritmayı yenileyecek olursak.

Adım 1: Başla

Adim 2: Oku(Vo, K1o,K2o,Oo) /* sınav oranlarını oku*/

Adim 3: Oku(Yilicio,Fo) /* genel başarı için yil içi ve final oranları oku */













Örnek alg. 8: Üçgenin alanının hesaplanması nı sağlayan bir algoritma tasarlayalım. Üçgenin

alanı aşağıdaki şekli de gösterilen parametreler ve denklem ile hesaplanır.

Ucgenin alanı=(taban*yükseklik)/2 ile hesaplanır

Adım 1: Başla

Adım 2: Oku (h) /* üçgenin yüksekliğini, h değişkenine oku */

Adım 3: Oku(taban) /* üçgenin taban uzunluğunu, taban değişkenine oku */

Adım 4: ucgen_alan=1/2(taban*h) /* üçgenin alanını hesapla */

Adım 5: Yaz (Ucgen_alan) /* hesaplanan sonucu (Ucgen_alan) ekrana yaz */

Adım 6: Dur

h

taban




Örnek alg.9; Klavyeden girilen iki sayının sırası ile toplamları, farkı, çarpımları ve

bölümlerini gerçekleştiren ve ekrana yazdıran algoritma

Adım 1: Başla

Adim 2: Oku(a) /* birinci sayıyı oku, a değişkenine ata*/

Adim 3: Oku(b) /* ikinci sayıyı oku, b değişkenine ata */

Adım 4: sonuc=a+b /* a ile b değişken değerlerini topla, sonuc değişkenine ata */

Adım 5: Yaz(sonuc) /* hesaplanan toplam değeri(sonuc) yazdır */

Adım 6: sonuc=a-b /* a ile b değişken değerlerinin farkını al, sonuc değişkenine ata

*/

Adım 7: Yaz(sonuc) /* hesaplanan fark değeri(sonuc) yazdır */

Adım 8: sonuc=a*b /* a ile b değişken değerleri çarp, sonuc değişkenine ata */

Adım 9: Yaz(sonuc) /* hesaplanan çarpım değerini(sonuc) yazdır */

Adım 10: sonuc=a/b /* a değişken değerini b değeri ile böl, sonuc değişkenine ata */

Adım 11: Yaz(sonuc) /* hesaplanan bölüm değerini(sonuc) yazdır, */


Örnek alg 10; Silindirin hacmini bulan bir algoritma tasarlayalım. Parametreler klavyeden

okunsun, hacim hesaplandıktan sonra ekrana yazdırılsın.

Hacim= taban alanı*yükseklik

Hacim=πr2h

Adım 1: Başla

Adım 2: Oku (h) /* silindirin yüksekliğini, h değişkenine oku */

Adım 3: Oku(r) /* silindirin yarı çapını, r değişkenine oku */

Adım 4: Oku(Pi) /* pi sayısını, pi değişkenine oku */

Adım 4: Silindir_Hacim=Pi*r*r*h /* silindirin hacmini hesapla */

Adım 5: Yaz (Ucgen_alan) /* hesaplanan sonucu (Silindir_Hacim) ekrana yaz */

Adım 6: Dur

Buraya kadar ki sözde kod yazımında problemlerimiz hep sıralı işlemlerden oluştu. Normalde

sıralı işlemler nadir karşımıza çıkar. Bir takım karar mekanizmalarına göre farklı işlemlerin

yürütülmesi problemleri sıklıkla karşılaşılan algoritmalardır. Örnegin silindirin hacmi

hesaplandıktan sonra başka parametre değerleri ile yeni silindir hacimleri hesaplanabilir. Bu

durumda algoritmamızda bir karar mekanizması gerekecektir. Bu kısımda algoritmalarımıza

karar mekanizmaları etkileyerek yenileyelim.

h yükseklik

r




Örnek alg. 11. Çok sayıda silindirin alanını hesaplayabileceğimiz bir algoritma tasarlayalım.

Programdan çıkış işlemini yüksekliğin sıfır ve sıfırdan küçük olması ile kontrol edelim.

Adım 1: Başla


Adım 3: Eğer h<=0 ise adım 9 ya git


Adım 5: Oku(Pi) /* pi sayısını, pi değişkenine oku */



Adim 8: adım 2 ye git

Adım 9: Dur

Algoritmada Pi sayısı sabit olduğundan dolayı klavyeden okunmayabilir. Bu

durumda algoritma aşağıdaki şekilde yeniden düzenlenebilir.


Programdan çıkış işlemini yüksekliğin sıfır ve sıfırdan küçük olması ile kontrol edelim ve Pi

sayısı sabit olarak atansın..

Adım 1: Başla

Adim 2:Pi=3.141618 /* pi sayısını, pi değişkenine ata */


Adım 4: Eğer h<=0 ise adım 9 ya git




Adim 8: adım 2 ye git

Adim 9: Yazdir(“Çıkış seçildi”)

Adım 10: Dur

Burada silindirin yüksekliği 0 ve sıfırdan küçük olamayacağından hesaplama yapmadan

programı sonlandırıyoruz. Yani kontrol başta yapılmakta.

Örnek alg. 13: örnek algoritma 7 deki problemde, tek öğrencinin başarı notunu hesaplayan

bir algoritma tasarlamıştık. Şimdi bunun çok sayıda öğrencinin başarı notunu hesaplayacak

şekilde geliştirelim.

Adım 1: Başla

Adim 2: cevap=’h’

Adim 3: Oku(Vo, K1o,K2o,Oo) /* sınav oranlarını oku*/

Adim 4: Oku(Yilicio,Fo) /* genel başarı için yil içi ve final oranları oku */















Adim 15: Yaz(“devam edilecek mi?”)

Adim 16: Oku(cevap)

Adim 17: Eğer devam edilecek(cevap==’e’) ise adım 2 ye git


Silindirin hacim hesabındakinin aksine öğrenci bilgileri ve not bilgileri girildikten sonra

başarı hesaplanmakta ve yeni öğrenci başarı hesaplamalarının yapılıp yapılmayacağı

sorulmaktadır. Yani kontrol işlem konumuz olan başarı hesaplamasından sonra yapılmaktadır.

Örnek alg. 14: Ardışıl olarak klavyeden girilen sayıların toplamını alan bir algoritma

tasarlayalım. Toplanacak sayı adedi biliniyorsa sıralı bir işlemlede çözülebilir. Ancak iyi bir

algoritma tasarlanmış olmaz. En iyi çözüm tekrarlı yapıdır.

Adım 1: Başla

Adim 2:Toplam=0,cevap=’h’ /*Toplam değişkenine sıfır ata */

Adim 3: Oku(a) /* ilave edilecek sayıyı oku, a değişkenine ata*/

Adim 4: Toplam=Toplam+a /* a değişken değerini toplam değişkenine ilave et */

Adım 5: Yaz(Toplam) /* hesaplanan toplam değeri(Toplam) yazdır */

Adım 6:Yaz(“yeni ilave edilecek mi?)

Adim 7: oku(cevap)

Adim 7:eğer cevap==’e’ ise adım 3 git

Adim 8: dur

Örnek alg.15;

Problem: klavyeden okunan sayı sıfırdan büyük ise karesini alıp sonucu ekrana yazan, sayı

sıfırdan küçük ise yürütmeyi sonlandıran bir algoritmanın tasarlanması.

Tasarım: kıyaslama gerektiğinden algoritmada if-then (eğer-ise) yapısı kullanılacak.

Adım 1: Oku (a) /* sayıyı a değişkenine oku */

Adım 2: Eğer a<0 ise Adım 6’ya git /* a<0 ise programı durdurmak için Adım 6’ ya git */

Adım 3: b=a*a /* a’nın karesini al ve b değişkenine ata */

Adım 4: Yaz (b) /* hesaplanan sonucu (b) ekrana yaz */

Adım 5: Adım 1’ e git /* yeni sayıyı okumak için Adım 1’ e git */


Örnek alg.16;




Problem: klavyeden okunan iki farklı sayıdan büyük olanı belirleyen ve ekrana yazan bir


Tasarım: iki sayı arasında kıyaslama ve seçim gerektiğinden algoritmada if-then-else (eğer-

ise-değilse) yapısı kullanılacak.

Algoritma sözde kodlar ile ifade edildiğinde aşağıdaki şekilde yazılabilir;

Adım 1: Oku (a) /* birinci sayıyı a değişkenine oku */

Adım 2: Oku (b) /* ikinci sayıyı b değişkenine oku */

Adım 3: Eğer a<b ise eb = b /* a<b ise, büyük olan b’ yi eb değişkenine ata */

değilse eb = a /* a<b değilse, büyük olan a’ yı eb değişkenine ata */

Adım 4: Yaz (eb) /* büyük olan sonucu (eb) ekrana yaz */


Örnek alg.17;

Problem: klavyeden okunan bir reel sayının karekökünü bulup sonucu ekrana yazan bir


Tasarım: öncelikle problemin çözümünün matematiksel olarak ifade edilmesi gerekmektedir;

a, karekökü bulunmak istenen sayı olun, x değeri a’nın tahmini karekökü ve b değeri ise

a’nın gerçek karekökü ile tahmin edilen karekökü arasındaki fark olsun. Bu durumda a

aşağıdaki şekilde ifade edilebilir;

a = (x+b)2 a = x

2+2xb+b

2

Küçük olması beklene b2 değeri ihmal edilirse, b değeri yaklaşık olarak hesaplanabilir;

b (a-x2)/2x

hesaplanan b değeri kullanılarak a’nın kareköküne daha yakın yeni bir tahmin yapılabilir;

xi+1 = xi + b /* burada xi önceki tahmin, xi+1 ise kareköke yakın yeni tahmin değeridir */

Bu şekilde a’nın karekökü girerek yakınsayan bir iterasyon (tekrarlama) ile bulunabilir.

a’nın karekökünü yakınsayarak bulan bu iteratif (mutlak hata b, hata değerinden küçük eşit

olana kadar işlem tekrar edilecek) algoritma sözde kodlar ile ifade edildiğinde aşağıdaki

şekilde yazılabilir (ifade kolaylığı için xi yerine x ve xi+1 yerine y kullanılarak);

A1: Oku (a) /* karekökü bulunacak sayıyı a değişkenine oku */

A2: Oku (x) /* ilk tahmini karekökü x değişkenine oku */

A3: Oku () /* kabul edilebilir hata değerini değişkenine oku */

A4: b=(a-x2)/2x /* fark (hata) değeri olan b’ yi hesapla */

A5: y=x+a /* daha yakın yeni karekök değerini (y) hesapla */




A6: Eğer b ise A9’a git /* b ise iterasyonu durdurmak için A9’e git */

A7: x=y /* y yeni karekök değerini x değişkenine ata */

A8: A4’e git /* işlemi yeni x tahmini ile tekrarlamak için A4’e git */

A9: Yaz (y) /* en son hesaplanan karekök değerini (y) ekrana yaz */

A10: Dur /* programı sonlandır */

Bu algoritmada işlemlerin bir çevrimin içinde tekrarlandığı ve istenilen hassasiyete

ulaşıldığında çevrimin dışına çıkılarak işlemin tamamlandığı görülmektedir. Bilgisayar da

program işletilirken bir değişkene yeni bir değer verildiğinde eski taşıdığı değerin kaybolacağı

not edilmelidir.

Aşağıda bu algoritmanın nasıl çalıştığı, işlemlerin her tekrarında (çevrimin her adımında)

değişkenlerin aldığı değerler bir çizelgede verilerek açıklanmıştır.a, x ve değerlerinin sırası

ile 31.8, 5.0 ve 0.005 olarak okunduğu kabul edilsin.

Çevrim adım no a x b y

31.8 5.0 0.005

1 31.8 5.0 0.005 0.68 5.68

2 31.8 5.68 0.005 -0.04 5.64

3 31.8 5.64 0.005 -0.0001 5.64

Çizelgeden de görüleceği gibi üçüncü çevrim adımında b değeri değeri olan 0.005’ den

küçük olduğu için yeni karekök değeri hesaplanmaz en son hesaplanan karekök değeri y=5.64

olarak kalır ve işlem sonlandırılır.

Örnek alg.18;

Problem: klavyeden okunan bir dizi harfin alfabetik sıraya konulmasını sağlayan ve sonucu

ekrana yazan bir algoritmanın tasarlanması.

Tasarım: öncelikle problemin çözümünün mantıksal olarak ifade edilmesi gerekmektedir;

Harflerin oluşturduğu diziye h adı verilsin ve dizinin n adet harften oluştuğu kabul edilsin.

Örneğin n=5 için h dizisi aşağıdaki şekilde olabilir;

B A E C D

Dizinin elemanları birbirinden indis kullanılarak (hi şeklinde) ayırt edilecektir. Örneğin

yukarıdaki dizide h3 E harfini ifade etmektedir. Sıralama harfleri ikişer ikişer ele alıp

karşılaştırarak ve gerekirse yerlerini değiştirerek yapılacaktır ve bu işlem dizi başına

dönülerek harfler alfabetik sıraya getirilene kadar devam ettirilecektir. Örneğin yukarıdaki

dizi ele alınır ise, ilk adımda A ile B’ nin yerleri değiştirilecek ikinci adımda B ile E oldukları

yerlerde kalacak, üçüncü adımda C ile E, dördüncü adımda D ile E yer değiştirecektir. Dizi

sonuna geldiğinde E yerini bulmuş olacaktır. Bu işlem dizi başına dönülerek harfler alfabetik

sıraya getirilene kadar çevrim devam ettirilecektir.




Bu işlemi gerçekleştirmek için sözde kod ile yazılan aşağıdaki algoritmada alfabetik sırada

önce olan harfin, sonrakinden daha küçük olduğu kabul edilmiştir.

A1: Oku (n) /* dizi eleman sayısını ata */

A2: Oku (h dizisi) /* h dizisinin n elemanını oku */

A3: k=n /* k’ ya n değerini ver */

A4: k=k-1 /* k’ yı bir eksilterek çevrim sayısını belirle */

A5: Eğer k=0 ise A14’e git /* k=0 a ulaştı ise A14’ e git (çevrimi atla) */

A6: i=0 /* dizi indis değerini sıfırla */

A7: i=i+1 /* dizi indis değerini bir artır */

A8: Eğer i>k ise A4’e git /* indis değeri çevrim değerinden büyükse A4’e git */

/* her çevrimde bir harf yerini yerleştiği için */

/* karşılaştırma indisi çevrim değerini aşmıyor,*/

/* yani yerini sağ tarafta yerine yerleşmiş */

/* karakterler tekrar kontrol edilmiyor */

A9: Eğer hi<hi+1 ise A7’ye git /* karşılaştırılan harflerin alfabetik sıralaması

doğru ise yer değiştirmeyi atla */

A10: b=hi /* geçici değişken b’ ye hi değerini ver */

A11: hi=hi+1 /* hi’ ye hi+1 değerini ver */

A12: hi+1=b /* hi+1’ e geçici b değişkenindeki eski hi değerini ver */

A13: A7’ ye git /* kıyaslamayı bir sağa kaydırmak için */

A14: Yaz (h dizisi) /* h dizisinin elemanlarını ekrana yaz */

A15: Dur /* programı sonlandır */

Algoritmanın değişkenlerinin algoritmanın çalışması sırasında alacakları değerler aşağıdaki

çizelgede gösterilmiştir. Başlangıçta belirsiz olan değişkenlerin her adım sonunda aldıkları

değerler bu çizelgede incelenebilir. Görüleceği gibi algoritmanın bazı adımları sadece bir kez

bazı adımları ise birçok kez işlem görmektedir.

İşlem adımı Algoritma adımı n h1 h2 h3 h4 h5 k i b

1 A1 5

2 A2 5 B A E C D

3 A3 5 B A E C D 5

4 A4 5 B A E C D 4

5 A5 5 B A E C D 4

6 A6 5 B A E C D 4 0

7 A7 5 B A E C D 4 1

8 A8 5 B A E C D 4 1

9 A9 5 B A E C D 4 1

10 A10 5 B A E C D 4 1 B

11 A11 5 A A E C D 4 1 B

12 A12 5 A B E C D 4 1 B

13 A13 5 A B E C D 4 1 B

14 A7 5 A B E C D 4 2 B

15 A8 5 A B E C D 4 2 B

16 A9 5 A B E C D 4 2 B

17 A7 5 A B E C D 4 3 B

18 A8 5 A B E C D 4 3 B




19 A9 5 A B E C D 4 3 B

20 A10 5 A B E C D 4 3 E

21 A11 5 A B C C D 4 3 E

22 A12 5 A B C E D 4 3 E

23 A13 5 A B C E D 4 3 E

24 A7 5 A B C E D 4 4 E

25 A8 5 A B C E D 4 4 E

26 A9 5 A B C E D 4 4 E

27 A10 5 A B C E D 4 4 E

28 A11 5 A B C D D 4 4 E

29 A12 5 A B C D E 4 4 E

30 A13 5 A B C D E 4 4 E

31 A7 5 A B C D E 4 5 E

32 A8 5 A B C D E 4 5 E

33 A4 5 A B C D E 3 5 E

34 A5 5 A B C D E 3 5 E

35 A6 5 A B C D E 3 0 E

36 A7 5 A B C D E 3 1 E

37 A8 5 A B C D E 3 1 E

38 A9 5 A B C D E 3 1 E

39 A7 5 A B C D E 3 2 E

40 A8 5 A B C D E 3 2 E

41 A9 5 A B C D E 3 2 E

42 A7 5 A B C D E 3 3 E

43 A8 5 A B C D E 3 3 E

44 A9 5 A B C D E 3 3 E

45 A7 5 A B C D E 3 4 E

46 A8 5 A B C D E 3 4 E

47 A4 5 A B C D E 2 4 E

48 A5 5 A B C D E 2 4 E

49 A6 5 A B C D E 2 0 E

50 A7 5 A B C D E 2 1 E

51 A8 5 A B C D E 2 1 E

52 A9 5 A B C D E 2 1 E

53 A7 5 A B C D E 2 2 E

54 A8 5 A B C D E 2 2 E

55 A9 5 A B C D E 2 2 E

56 A7 5 A B C D E 2 3 E

57 A8 5 A B C D E 2 3 E

58 A4 5 A B C D E 1 3 E

59 A5 5 A B C D E 1 3 E

60 A6 5 A B C D E 1 0 E

61 A7 5 A B C D E 1 1 E

62 A8 5 A B C D E 1 1 E

63 A9 5 A B C D E 1 1 E

64 A7 5 A B C D E 1 2 E

65 A8 5 A B C D E 1 2 E

66 A4 5 A B C D E 0 2 E

67 A14 5 A B C D E 0 2 E




68 A15 5 A B C D E 0 2 E

Çizelgede verilen başlangıç örnek dizisi için algoritma, dizi kısmen kolay olduğu için, 29.

adımda alfabetik sıralamayı tamamlamıştır. Fakat algoritma daha karmaşık ve uzun dizileri de

değişiklik yapmadan çözebilmesi için bütün kontrolü tamamlayana kadar işleme devam eder.




2. AKIŞ DİYAGRAMLARI

Problemi çözmek için, problemin anlaşılır bir biçimde ortaya konulması

gerekmektedir. Algoritmalar bu açıdan önemli bir araçtır.

Akış diyagramı, algoritmaların geometrik şekillerle ortaya konulmasıdır. Akış

diyagramı, problemin çözümü için yapılması gerekenlerin, başından sonuna kadar

geometrik şekillerden oluşan semboller ile ifade edilmesidir.

Her simge genel olarak yapılacak bir işi veya komutu gösterir.

2.1. Akış Diyagramı Sembolleri

Başla: Programın nereden başlayacağını belirtir. Standart olarak her bağımsız

algoritmada bir tane bulunur.

Dur: Programın nerede sonlanacağını bildirir. Birden fazla olabilir. Mümkün ise

sadece bir dur simgesi kullanılmalıdır.

Giriş: Bilgisayara dışardan bilgi girişini temsil eder. Bu sembolün içine dışarıdan

girilen bilgilerin aktarılacağı değişkenler yazılır.

Çıkış: Ekrana veya yazıcıya bilgi göndermeyi temsil eder.

İşlem: Programın işlemesi sırasında yapılacak işlemleri ifade etmek için kullanılır.




Karşılaştırma (sorgu): Verilen koşulun sonucuna göre farklı işlem yapılacağını ifade

etmek için kullanılır.

Döngü: Belirli bir işin veya bir grup işin birden çok sayıda yinelenmesi gerektiğinde

kullanılır. Döngüdeki çevrim sayısı, döngü sayacı ve sayaç artırımı açıkça yazılır.

Fonksiyon Çağırma: Daha önce oluşturulmuş bir algoritmanın yazılan algoritma

içerisine konulmadan çağırılarak kullanılmasını ifade eder.

Dosyaya saklama: Elde edilen bilgilerin bir dosyaya saklanması veya dosyadan

okunmasını simgeler.

Akış Yönü: Bir işlem bittikten sonra akışın nereye yöneleceğini belirler.




Bağlantı: Akış diyagramı çizilirken sayfaya sığmama durumunda çizimin başka bir

yerden devam etmesi için kullanılır.

Aynı sayfaya Ayrı sayfaya

2.2. Örnek akış diyagramları

Örnek alg. 1; klavyeden girilen iki sayının toplamını bulup sonucu ekrana yazdıran bir

algoritma tasarlamıştık. Bu sözde kodunu yazdığımız algoritmayı, akış diyağramı ile ifade

edelim

sıralı bir işlemlerden oluştuğunu ifade etmiştirk. Yani her hangi bir karşılaştırma durumu ve

buna bağlı farklı işlemlerden biri seçilmemektedir.

Algoritma akış diyagramı aşağıdaki şekilde yazılabilir;

Örnek alg. 2: Bir kenarı klavyeden girilen karenin alanını hesaplayan ve ekrana yazdıran bir

algoritmanın akış diyağramının tasarlanması.Bu örnekte de sıralı bir işlem vardır.

a,b

c=a+b

c

Dur

Başla




Örnek alg. 3: İkinci dereceden katsayıları bilinen bir fonksiyonun, klavyeden girilen x değeri

için alacağı değeri hesaplayıp sonucu ekrana yazdıran bir algoritma tasarlayalım. Bu örnekte

de sıralı bir işlem vardır.


F(x)=x^2+3x+4

Fonksiyonun x in -100 ile 100 arasındaki 20 artım ile çizilmiş grafiği şekil de verilmiştir. Bu

algoritmada sadece girilen bir x değeri için bir hesap yapılacak ve sonlanacağından dolayı

sıralı bir işlem yapılmalıdır.

0

2000

4000

6000

8000

10000

12000

-150 -100 -50 0 50 100 150

f(x)

f(x)

a

Kare_alan=a*a

Kare_alan

Dur

Başla




Örnek alg. 4: Örnek 3 de verilen problemde katsayıları belli bir İkinci dereceden denklemim

hesaplanması istenmiş idi, eğer katsayılarıda klavyeden girilecek ise ozaman algoritma akış

diyağramı aşağıdaki şekilde düzenlenebilir


F(x)=a*x^2+b*x+c

Örnek alg. 5: Bir öğrencinin dönem içerisindeki ve dönem sonundaki notlarını klavyeden

okuyan, Yıliçi ve Başarı notunu bilinen katsayılara göre hesaplayan algoritmanın akış

diyağramını tasarlayalım.

x

fx=x*x+2*x+4

fx

Dur

Başla

a,b,c

fx=a*x*x+b*x+c

fx

Dur

Başla

x




Öğrencilerin notlarını gösteren liste genelde şekil de verilen tablodakine benzerdir.

Öğrencinin Vize, kısa sınav 1, kısa sınav 2 ve ödev notu belli oranlarda alınarak yıl içi başarı

notu bulunur. Final notunun belirli bir yüzdesi ile yıl içi notunun %100’e tamamlanacak

yüzdelik oranı ile başarı puanı bulunur. Örneğin

Yıl içine etki yüzdeleri

Vizenin %60 ‘ı,



Ödev notu’nun %20,

Başarı Notu

Yıliçi Nounun %50,

Final Notunun %50

Olsun

Bir öğrencinin notunu hesaplayacak şekilde algoritmayı belirtilen katsayılar için

gerçekleştirecek olursak

Ogr_Adi,Ogr_No

Vize,K1,K2,Odev

Final

Yilici=0,60*Vize+0,1*K1+0,1*K2+0,2*Odev

Basari

Dur

Başla

Basari=0,5*Yilici+0,5*final






değişmesini gerektirecektir. Algoritmayı yenileyeek olursak.

Bu algoritmada katsayılar değişkenlere atandı ve istenildiğinde değişken değerleri

değiştirilerek program tekrar çalıştırılabilir. Ancak hala algoritma esnek değil. Bu esneklik

ancak bu değerler klavyeden okunduğunda oluşacaktır.



değişmesini gerektirecektir. Algoritmayı yenileyecek olursak.

Ogr_Adi,Ogr_No

Vize,K1,K2,Odev

Final

Yilici=Vo*Vize+K1o*K1+K2o*K2+Oo*Odev

Basari

Dur

Başla

Basari=Yilicio*Yilici+Fo*final

Vo=0,5, K1o=0,1,K2o=0,1,Oo=0,2

Yilicio=0,5,Fo=0,5




Örnek alg. 8: Üçgenin alanının hesaplanması nı sağlayan bir algoritma akış diyağramı

tasarlayalım. Üçgenin alanı aşağıdaki şekli de gösterilen parametreler ve denklem ile

hesaplanmakta idi.

Ucgenin alanı=(taban*yükseklik)/2 ile hesaplanır

Ogr_Adi,Ogr_No

Vize,K1,K2,Odev

Final


Basari

Dur

Başla


Vo, K1o,K2o,Oo,

Yilicio, Fo

h

taban




Örnek alg.9; Klavyeden girilen iki sayının sırası ile toplamları, farkı, çarpımları ve

bölümlerini gerçekleştiren ve ekrana yazdıran algoritma akış diyagramı

h,taban

ucgen_alan=1/2(taban*h)

ucgen_alan

Dur

Başla

a,b

sonuc=a+b

sonuc

Dur

Başla

sonuc=a-b

sonuc

sonuc=a*b

sonuc

sonuc=a/b

sonuc

a,b

sonuc=a+b

sonuc

Dur

Başla

sonuc=a-b

sonuc

sonuc=a*b

sonuc

sonuc=a/b

sonuc




Örnek alg 10; Silindirin hacmini bulan bir algoritma için akış diyağramı tasarlayalım.

Parametreler klavyeden okunsun, hacim hesaplandıktan sonra ekrana yazdırılsın.

Hacim= taban alanı*yükseklik

Hacim=πr2h

Buraya kadar ki akış diyağramı problemlerimiz hep sıralı işlemlerden oluştu. Normalde sıralı

işlemler nadir karşımıza çıkar. Bir takım karar mekanizmalarına göre farklı işlemlerin

yürütülmesi problemleri sıklıkla karşılaşılan algoritmalardır. Örnegin silindirin hacmi

hesaplandıktan sonra başka parametre değerleri ile yeni silindir hacimleri hesaplanabilir. Bu

durumda algoritmamızda bir karar mekanizması gerekecektir. Bu kısımda algoritmalarımıza

karar mekanizmaları etkileyerek yenileyelim.

Örnek alg. 11. Çok sayıda silindirin alanını hesaplayabileceğimiz bir algoritma için akış

diyağramı tasarlayalım. Programdan çıkış işlemini yüksekliğin sıfır ve sıfırdan küçük olması

ile kontrol edelim.

h yükseklik

r

h,r,Pi

Silindir_Hacim=Pi*r*r*h

Silindir_Hacim

Dur

Başla




Algoritmada Pi sayısı sabit olduğundan dolayı klavyeden okunmayabilir. Bu

durumda algoritma aşağıdaki şekilde yeniden düzenlenebilir.


Programdan çıkış işlemini yüksekliğin sıfır ve sıfırdan küçük olması ile kontrol edelim ve Pi

sayısı sabit olarak atansın..

h


Silindir_Hacim

Dur

Başla

h≤0

r,Pi

Hayır

Evet

h


Silindir_Hacim

Dur

Başla

h≤0

r

Hayır

Evet

Pi=3.141618




Burada silindirin yüksekliği 0 ve sıfırdan küçük olamayacağından hesaplama yapmadan

programı sonlandırıyoruz. Yani kontrol başta yapılmakta.

Örnek alg. 13: örnek algoritma 7 deki problemde, tek öğrencinin başarı notunu hesaplayan

bir algoritma için akış diyağramı tasarlamıştık. Şimdi bunu çok sayıda öğrencinin başarı

notunu hesaplayacak şekilde geliştirelim.

Ogr_Adi,Ogr_No

Vize,K1,K2,Odev

Final


Basari

“devam edilecekmi?”

Dur

Başla


Vo, K1o,K2o,Oo,

Yilicio, Fo

cevap=’h’

cevap

cevap==’e’ evet

hayır




Silindirin hacim hesabındakinin aksine öğrenci bilgileri ve not bilgileri girildikten sonra

başarı hesaplanmakta ve yeni öğrenci başarı hesaplamalarının yapılıp yapılmayacağı

sorulmaktadır. Yani kontrol işlem konumuz olan başarı hesaplamasından sonra yapılmaktadır.

Örnek alg. 14: Ardışıl olarak klavyeden girilen sayıların toplamını alan bir algoritma için akış

diyağramı tasarlayalım. Toplanacak sayı adedi biliniyorsa sıralı bir işlemlede çözülebilir.

Ancak iyi bir algoritma tasarlanmış olmaz. En iyi çözüm tekrarlı yapıdır.

Örnek alg.15;

Problem: klavyeden okunan sayı sıfırdan büyük ise karesini alıp sonucu ekrana yazan, sayı

sıfırdan küçük ise yürütmeyi sonlandıran bir algoritmanın tasarlanması.

Tasarım: kıyaslama gerektiğinden algoritmada if-then (eğer-ise) yapısı kullanılacak.

a

Toplam=Toplam+a

Dur

Başla

Toplam=0

cevap=’h’

Toplam

“devam edilecekmi?”

cevap

cevap==’e’ evet

hayır




Örnek akış.16;

Örnek alg.3 için akış diyagramını çizelim.

Aşağıdaki şekilden de görülebileceği gibi akış diyagramlarında işlem sırası oklarla

gösterildiği için deyimlerin (işlemlerin) A1, A2, vb. etiketlendirilmesine gerek yoktur.

Fakat istenirse bu etiketler kutuların dışında sol üst köşeye yazılabilir.

a

b=a*a

b

Dur

Başla

A≤0




Örnek akış.17;

1’den N’ye kadar olan sayıların toplamını hesaplayan programın akış diyagramını

çizelim.

1’den N’ye kadar N adet sayı vardır. Birer artan döngü içinde sayıları toplayabiliriz.

Döngü artışını kontrol edeceğimiz değişken i olsun. Toplam değerini de T değişkeni

ile ifade edelim. Döngü değişkeni i, 1’den başlayacak ve birer artarak N ye ulaşacak. T

başlangıçta 0 ile başlayacak ve döngü içerisinde 1’den N’ye değişen i değeri ilave

edilecek.




N= 10 girilmesi durumunda akış diyagramı ile gösterilen programın çalışma sırasında i

değişkenine göre T değerlerini gösteren çizelge aşağıdaki şekilde ifade edilebilir;

i N işlem T

- 10 - -

- 10 T=0 0

1 10 T=0+1 1

2 10 T=1+2 3

3 10 T=3+3 6

4 10 T=6+4 10

5 10 T=10+5 15

6 10 T=15+6 21

7 10 T=21+7 28

8 10 T=28+8 36

9 10 T=36+9 45




10 10 T=45+10 55

Örnek akış.18;

NxM boyutlu iki matrisin toplamını hesaplayan bir algoritmanın akış diyagramını

çizelim.

Matrislerin elemanlarını ifade eden indisleri i ve j ile gösterelim (i=1,...,N, j=1,...,M).

Bu durumda A matrisinin her bir elemanı matematiksel olarak Ai,j veya programlama

açısından A[i][j]şeklinde ifade edilebilir.

Elemanları toplanacak matrisler A ve B matrisleri ve toplam sonucunda oluşacak

matris C matrisi olsun.

Bilindiği gibi matris toplamında birinci matrisin [i][j] elemanı ile ikinci matrisin

[i][j]elemanı karşılıklı olarak toplanarak toplam matrisin [i][j] elemanını oluşturur.

21

31][A ,

03

12][B matrisleri ve N=M=2 değerleri için,




yukarıdaki akış diyagramı ile gösterilen programın çalışma sırasında i ve j değişkenlerine göre

C[i][j] değerlerini gösteren çizelge aşağıdaki şekilde ifade edilebilir;

i j işlem C[i][j]

1 1 C[1][1]=1+2 3

1 2 C[1][2]=3+1 4

2 1 C[2][1]=1+3 4

2 2 C[2][2]=2+0 2

Bu durumda oluşan C matrisi;

24

43][C olur.

Örnek akış.19; İkinci dereceden bir denklemin köklerinin hesaplanması için bir akış

diyağramı tasarlayalım. İkinci dereceden bir denklemin köklerinin hesaplanması aşağıdaki

denklem ile gerçekleştirildiğini biliyoruz.

a,b,c

Delta=b*b-4*a*c

Dur

Başla

“I. Kök= “, X1

“II. Kök= “, X2

evet

hayır

Katsayıları

giriniz

Delta≥0

X1=(b - sqrt(delta))/2*a

X2=(b + sqrt(delta))/2*a

“Kökler

karmaşıktır”




20

Adim 1: başla

Adim 2: x1=10, y1=20,r1=2

Adim 3: x1=10, y1=20,r2=2

Adim 4: oku(yon)

Adim 5: eğer yon= ’d’ ise x=x+1

Adim 6: eğer yon=’a’ ise x=x-1

Adim 7: eğer yon=’s’ ise y=y+1

Adim 8: eğer yon=’x’ ise y=y-1

Adim 9: Mesafe=sqrt(power(|x2-x1|,2)+power(|y2-y1|))

Adim 10: eğer mesafe>(r1+r2) ise “çarpışma yok”

Değil ise “çarpışma var”

Adim 11:eğer yon eşit değil ‘e’ git adim 4

Adim 12: dur

Asansör

Adim 1: başla

Adim 2: yon=0 /0 duruyor, 1 yukarı, 2 aşağı

Adim 2: oku(Bkat) /başlagıç durumu

Adim 3: oku(istek) / istekleri dinle

Bkat=1 ve istek=1 ise

ÖDEV 1

Soru 1.1;

Verilen bir x değeri için aşağıdaki şekilde gösterilen fonksiyonu hesaplayan bir algoritma

yazınız.

Soru 1.2;




a) Aşağıda verilen akış diyagramının ifade ettiği işlemi bulunuz.

b) Bu akış diyagramına uygun bir algoritmayı yazınız ve akış diyagramını çiziniz.

c) Aşağıda verilen A (NxR boyutlu) ve B (RxM boyutlu) matrisleri ve N, M, R değerleri için

yazdığınız algoritmanın değişkenlerinin algoritmanın çalışması sırasında alacakları değerleri

bir çizelge ile gösteriniz ve sonuçta oluşan C (NxM boyutlu) matrisini yazınız.

20

21][A ,

20

02][B , 2 RMN

Soru 1.3;




Değişik harf ve rakamların karelere bölünmüş bir alanda belirli kareler siyah yapılarak

gösterildiğini kabul ediniz. Örneğin A harfi aşağıdaki gibi gösteriliyor;

Dolu karelerin 1 ve boş karelerin 0 ile ifade edildiğini kabul edelim. Verilen harfi yada rakamı

belirlemek için kullanılabilecek bir algoritmanın ön tasarımını mantıksal (algoritmayı sözde

kod ile yazmadan) olarak yapınız.




3. PROGRAMLAMA VE PROGRAMLAMA DİLİ

Programlama, bir işlemin bilgisayarın anlayabileceği bir biçime dönüştürülmesi

işlemidir.

Program, bilgisayar sistemine yaptırılmak istenen işlemi özel kodlarla tanımlayan araç

olarak bilinir. Program, bir programlama dili aracılığıyla hazırlanır.

Kullanılacak programlama dili çözülecek problemin niteliğine bağlı olarak seçilebilir.

Hangi dilin seçileceğini belirleyen etkenlerin başında, verilerin işlenmesinde zaman

tasarrufu yada komut sayısını sınırlamak olabilir.

Programlama dili, program tasarımında sorulardan biri tasarlanan çözümlemeye

uygun programlama dilini seçmektir. Programlama dilleri, bilgisayarda çalıştırılmak

üzere hazırlanır.

Bir programlama dilinin belirli amaçlara hizmet eden bir çok deyimi vardır ve bu

deyimler özel kodlarla ifade edilir. Programlama dillerinin ortak özellikleri vardır.

Programlama dillerinin tümü simgesel’dir. Yani, bilgisayarın anlayacağı işlemleri

insanların da anlayabileceği simgelerle ifade ederler. Örneğin program içinde yer alan

write/print komutunun, yazma işlemini yerine getiren bir komut olduğu hemen

anlaşılır. Bu simgeler, özel programlar yardımıyla bilgisayarın anlayabileceği bir

biçime çevrilirler. Bu programlara derleyici adı verilir

Programın yazımı, kaynak programın geçerli makine diline derleyici aracılığı ile

çevrilmesi için kaynak programın bilgisayar ortamında bir yazım/editör programı

yardımı ile, gerçekleştirilir.

Programım yazımında anlaşılabilirlik ve okunabilirlik önem taşır. Program yazma, ilk

kez yazma veya var olan programı geliştirme şeklinde olabilir. Programlar çoğunlukla

ilk kez yazıldığından sonra üzerinde düzeltme ve geliştirmeler yapma gerektirir. Bu

nedenle, diğer taraftan programlar bir kez kullanılmak için de hazırlanmaz bir süre

sonra programa bakıldığında anlaşılabilir olma önemli olur. Açıklama satırları

eklemek, program işlem kümelerini, yordamları, yapıları izlenebilir yapıda yazmak

sonrada izlenebilmeye kolaylık sağlar.

Değişkenlere, yordamlara işlev ve görevini anımsatacak isimler vermek, karar

işlemlerini anlaşılır açıklıkta yazmak, okunabilirliğine yardım edecektir.

Dil derleyiciler (compilers), elektronik ortamda disk kütüğü yapısında hazırlanan

kaynak programın işleyebilir makine diline dönüştürülmesi, kullanılan üst düzey dil

için hazırlanmış dil derleyicisi yazılımları ile gerçekleştirilir. Örneğin, C ve C++

destekleyen Turbo C++, Borland C++, MS Visual C++ derleyicileri yaygın kullanılan

dil derleyicilerindendir.




Derleme: derleme işlemi üst düzey dille hazırlanan kaynak programı geçerli makine

dili içerikli amaç programa dönüştürür. Bu dönüştürme süreci bir adımda

gerçekleşmez. Örneğin C Derleyicisi derleme (compile), bağlama (linker), yükleme

(loader) işlemleri sonunda işleyebilir amaç programa (makine kodu) dönüşür.

3.1. C/C++ da yazılan programların derlenmesi

Tüm yüksek seviyeli programlar gibi C ve C++ dillerinde de program yazıldıktan

sonra çalıştırılabilmesi için derleyici ile makine diline çevrilmesi gerekir.

Program ilk olarak bir editörde yazılır. Bu programa kaynak (source) program ve

içindeki kodlara kaynak (source) kodlar denir. Derlendikten sonra programın makine

dilindeki versiyonu nesne (object) program adını taşır ve .obj uzantılı olur.

Derlendikten sonra çalışmaya hazır programın uzantısı .exe olur ve buna exe programı

denir. {execute: yürütme}

Derlenmeden önce kaynak program, sabit diske dosya şeklinde kaydedilmelidir. Bir

çok C++ derleyicisi kaynak programın .cpp (.c) uzantılı bir dosya olmasını bekler.

Örneğin: ornek1.cpp (ornek1.c)

C++ dilinde bir programın oluşturulması, derlenmesi ve çalıştırılması aşağıdaki iş akış

diyagramı ile ifade edilebilir;

Günümüzde en yaygın C/C++ derleyicileri, Turbo C++, Microsoft C++ ve Borland

C++ derleyicileridir.

Ayrıca Visual C++ ve Visual C++’ı içeren Microsoft Visual Studio.NET derleyicileri

konsol (Windows ortamında çalışan DOS programları) denilen bir çeşidi ile C/C++

programlarını derleyebilmektedir.




Bu derleyiciler program editörü ve derleyicisini bir arada bulundururlar.

3.2. C/C++ da programlama

C/C++ programlama dili, fonksiyon olarak adlandırılan altprogramların birleştirilmesi

kavramına dayanır. Bir C/C++ programı, bir yada daha çok fonksiyonun bir araya

gelmesi ile oluşur.

Bir fonksiyona ait kodlar blok şeklinde iki büyük { } parantez içinde yazılır. C/C++

programlarında main() özel bir fonksiyondur ve programın yürütülmesine bu

fonksiyon ile başlanır. Her C/C++ programında ana fonksiyon olan bir tane main()

bulunmalıdır.

Bir C++ programının temel yapısı aşağıdaki gibidir;

/* Önişlemci komutları */

/* Genel bildirimler */

main () /* Ana fonksiyon */

{

/* Program kodları */

}

Örnek C/C++ programı;

#include <stdio.h> /* Önişlemci komutları */

int n; /* Genel bildirimler */

void main(void) /* Ana fonksiyon */

{

n=7;

printf("n degeri=%d",n);

}

3.3. C/C++’ da önişlemci komutları

Bir C programında simgesel sabitler, makro fonksiyonlar veya programın koşullu

derlenmesi istenirse, önişlemci komutları olarak adlandırılan komutlar kullanılır. C dili

önişlemcisi, derleme işlemine geçmeden önce bu komutları yorumlayarak istenilenleri

yerine getirir, ardından derleme işlemine başlanır.




ANSI C’ de var olan ön işlemci komutları;

#define #error #include #pragma #undef

#endif #elif #if #else # inline

#ifndef #ifdef #line

#include önişlemci komutu;

Başlık dosyalarında (*.h) bildirilmiş olan makro fonksiyonlar ve simgesel sabitler

kullanılacak ise ilgili dosya #include önişlemci komutu kullanılarak program içine

eklenmelidir. Örneğin;

#include <stdio.h> /* C de kullanılan standart giriş çıkış fonksiyonların birçoğu */

/* stdio.h adlı başlık dosyasında bildirilmiş olan bir kısım */

/* veri tiplerini ve makro fonksiyon tanımlarını kullanır */

/* Bu yüzden standart giriş fonksiyonları kullanılırken */

/* stdio.h dosyası #include <stdio.h> komutu ile dahil edilir.*/

Başlık dosyalarının önceden derlenmiş olması nedeni ile derleyici sadece program

içinde yazılan kodları derler ve böylece derleme zamanından tasarruf sağlar.




Veri türleri, değişken kavramı, sabit ve değişken bildirimleri ve c ‘de dullanımı

Günlük yaşantımızda, kullandığımız verilere baktığımızda, metin, sayısal veriler ve mantıksal

olarak doğru, yanlış gibi temelde veriler kullanmaktayız. Bilgisayar da veri kullanımına

geldiğimizde bu veri türleri çeşitlendirilmektedir. Bunun en başta gelen sebebi hafıza nın en

verimli şekilde kullanılmasıdır. Bilindiği üzere bilgisayar, programları çalıştırmak için, Ana

hafıza dediğimiz RAM hafızayı kullanır. Ana hafıza byte lar topluluğundan oluşmaktadır. 8

bit bir byte yapmaktadır. En anlamlı hafıza birimidir. En küçük hafıza birimi ise bit tir ve

bilgisayarda veri saklama bakımından bir önemi yoktur. Ancak byte bilgilerin bit bit

değerlendirilmesi durumunda bir önem arzeder.

Bilgisayarda ana hafızayı verimli kullanmak, bilgisayar tarihi boyunca en önemli konu

olmuştur. Günümüzde, Ana hafıza her ne kadar ucuzlamış ve kapasite olarak fazla olsada

verimli kullanmaya hala eskisi kadar ihtiyaç duyulmaktadır. Byte kavramı bilgisayarda bir

karakteri saklamak için gerekli en küçük hafızadır. İkili sayı sistemine göre 8 bit ile 256

derecelendirme yapılmaktadır. ASCII karakter kodlaması ile, kullanılabilecek karakterler,

alfabenin karakterleri, *,+, ? vb kodlanmıştır. Dolayısı ile metin verilerde karakterin her biri

bir byet yer kaplayacaktır.

Sayısal verilerde ise durum daha farklıdır. Günlük yaşantımızda kullandığımız alana bağlı

olarak sayılar belli aralıklarda, tam sayı veya ondalık sayı olarak karşımıza çıkmaktadır.

Örneğin bir ürünün sayısını belirlemek için tam sayılar kullanılabilir ve 256 aetten fazla

olmayacak ise bir byte ile ifade edilebilirken, adet bilgisi 256 dan fazla ise o zaman bir byte

yetmeyecektir. Bu durumdada sayıyı ifade etmek için iki byte kullanılacaktır. Görüldüğü

üzere bir byte kullanılması gereken veri için iki byet kullanmak ihtiyaç olmadığı halde iki kat

hafıza kaplayacaktır.

Temel veri türleri: her programlama dili, hafızayı verimli kullanmak üzere, veri

gereksiniminin bellekte tutulması için tanımlanmış veri türlerine sahiptir. Bu veri türleri temel

veri türleridir. C/c++ programlama dillerinde, int, char, short int, double, vb temel veri

türleridir.




Temel veri türlerinin yanınta kullanıcı, veri organizasyonunu daha iyi yapmak ve kullanımda

rahat etmek için kendisi temel veri tiplerini kullanarak kunlanıcı tanımlı veri türleri

oluşturabilmektedir. Örneğin c/c++ programlama dilinde, yapılar, nesne tanımlamaları bu

türdendir.

Değişken, simgesel adlardır ve programcıyı donanımdan soyutlar. Programın çalışması

sırasında veriler hafızada tutulur. Hafıza ise 16 sayı siteminde adreslenmiş, byte lar dizisi

şeklindedir. Günümüzde çok görevli programlama dillerinde, hafıza kullanımı oldukca

karmaşıktır, gerçek hafıza adresleri ile uğraşmak ise içinden çıkılmaz bir durum oluşturur. Bu

yüzden değişkenler kullanılır ve hafızadaki veriyi sembolize eder. Yani değişken, verilerin

tutulduğu bellek hücrelerine verilen simgesel adlardır. Dolayısı ile program içerisinde

kullanılacak veriler değişkenler üzerinde tutulur. Programların yürütülmesi süresince

içerikleri değiştirilebilir.

Değişkenler bir düzen içerisinde kullanılır. Değişkenlerle ilgili temel kurallar;

Her değişkenin bir adı veri tipi vardır. Veri tipi değişkende ne tip veri tutulacağını

belirler.

C dilinde değişken adları, ilki harf olmak üzere diğerleri harf, sayı veya alt eksi ( _ )

den oluşan bir veya birden çok karakterden oluşur.karakterler İngiliz alfabesinin

karakterleridir. Örneğin bazı Türkçe karakterlerde değişken tanımlamak mümkün

değildir.

Değişken adları, dilin anahtar sözcükleri, kütüphanede var olan fonksiyon adları

olmamalıdır.

Her değişkenin tuttuğu değerin nasıl bir veri olduğunu gösteren bir tipi vardır.

Sabitler de bellekte verinin saklandığı hücrelere verilen sembolik adlardır.

Değişkenlere benzerler, fakat bildirilirken verilen değerler programın yürütülmesi

süresince değiştirilemez.




Sabitler program boyunca değerleri değiştirilmeyen yani sabit kalan değişkenler

olarak ta düşünülebilir.

Değişken ve sabit tipleri

Bilgisayar bir makinedir ve insan gibi yorum yapamaz. Bu yüzden programda işlem gören

değişken ve sabitlerin veri tipleri, bilgisayarın bu değerler ile işlem yapabilmesi için

verilmelidir. Daha önce belirtildiği gibi veri tipi bir değişken veya sabitin sayısal, karakter

veya başka tipteki niteliğini belirler. Doğal dillerde olduğu gibi programlama dilllerininde

yazım kuralları vardır. Bu kurallara uygun yazılmadığında program çalışmaz. En çok yapılan

hatalarda yazım hatalarıdır. Özellikle programlama dilini yeni öğrenmeye başlayanlar bu tür

hataları çok yapmaktadırlar. Herhangi bir değişken veya sabitin programda kullanılabilmesi

için programda yer alabilmesi için uygun bir yerde bildirilmesi (declaration) gerekmektedir.

Değişen ve sabit bildirimlerinde bir değişken adı ve türü belirtilir.

Bir değişken veya sabit elemanın sayı veya karakter şeklinde genel olarak tiplerinin

belirlenmesi tek başına yeterli değildir. Bir elemanın bildirilmesi ile ona bilgisayar belleğinde

bir yer ayrılır. Bu bildirim ayrılacak yerin büyüklüğü hakkında da bilgi verecek şekilde daha

detaylı olmalıdır. Daha önce belirtildiği üzere bellekte az ve çok yer tutacak veri tiplerine aynı

miktarda yer ayırmak bellekte yer israfına yol açacak, dolayısı ile hem işlemin daha uzun

sürede yapılmasa (gereksiz bellek okumaları) hem de donanım maliyetini artıracak (bellekte

aynı miktar yer ayrılması, verilerin o yere sığabilmesi için en çok yer kaplayan veri tipine

göre yer ayırmayı gerektirir). Bu nedenle veri tipinin bildirilmesi bellekte ayrılacağı yerin

büyüklüğünü de içermelidir. C dilinde kullanılan temel veri tipleri bool ve void hariç aşağıda

verildiği gibidir;

o char: karakter {A,b,@,<, vb.}

o int, short, long: tamsayı {1, 1245, vb.}

o float, double, long double: gerçel sayı {3.14, 104, vb.}

o char []: söz dizisi (string) {“Sakarya”, vb.}

o []: dizi, matris {[12 13 1], vb.}

Diğer programlama dillerinde de kendine özgü gösterimleri ile benzer temel veri tipleri

kullanılır.




C dilinde kullanılan türetilmiş veri tipleri aşağıda verildiği gibidir;

o enum: sıralamalar {pzt, sa, çar, per, …}

o struct: topluluk

o işaretçiler (pointers)

o class: sınıf

o vb.

C/C++ da temel veri tipleri

Karakter

C programlama dilinde “char” ile temsil edilen bu veri tipi tek bir karakterin ifade

edilmesini sağlar ve bellekte 1 byte (8 bit) büyüklüğünde yer işgal eder. ‘a’,’B’,’3’, vb.

şeklindeki karakterleri ifade eder.

En yaygın kullanılan karakter tablosu ASCII tablosudur. Standart ASCII’ de her bir

karakter 7 bittir ve 128 farklı karakter vardır. Extended (genişletilmiş) ASCII’ de her

bir karakter 8 bittir ve 256 farklı karakter vardır. Uygulamada daha çok genişletilmiş

ASCII tablosu kullanılmaktadır.

Ayrıca unikod kodlama da yaygınlaşmaktadır ve evrensel bir kodlama şeklidir. Bu

kodlamada her karakter 16 bit yer işgal eder ve 65536 (216

) tane farklı karakter

kodlanabilir. Her ülkenin bir sayfası vardır dolayısı ile karakter uymsuzlukları

problemlerine bir çözüm getirir.

Örnek bildirimler;

char cevap;

char kr;

char secim, k1

Tamsayı




C programlama dilinde “int” ile temsil edilen veri tipi normal tam sayıların ifade

edilmesini sağlar ve bellekte derleyiciye bağlı olarak 2 yada 4 byte büyüklüğünde yer

işgal eder.

Bazı özel niteleyiciler kullanılarak (short, unsigned, long) bu temel veri tipinin

türevleri elde edilir.

“short int” ile temsil edilen veri tipi kısa tam sayıların ifade edilmesini sağlar ve

bellekte derleyiciye bağlı olarak 2 byte‘ ı (16 bit) geçmeyecek uzunlukta ve genelde

normal veri tipinin yarısı büyüklüğünde yer işgal eder.

“long int” ile temsil edilen veri tipi uzun tam sayıların ifade edilmesini sağlar ve

bellekte derleyiciye bağlı olarak genelde normal veri tipinin iki katı büyüklüğünde yer

işgal eder.

“unsigned int” ile temsil edilen veri tipi işaretsiz (pozitif) tam sayıların ifade

edilmesini sağlar.

Tamsayı için 16 bit kullanan bir derleyicide, tamsayı -32768 ile +32767 arasında

olmalıdır (1 bit işaret biti, 215

=32768). Eğer tamsayı işaretsiz bildirilir ise atanacak

sayı 0 ile 65535 arasında olmalıdır (216

=65536). {(1111111111111111)2 =(65536)10}

Diğer derleyiciler içinde benzer hesaplama yapılabilir.

Derleyicinin kullandığı veri tipi uzunluğunu byte olarak sizeof operatörü ile

öğrenebiliriz.

Örneğin;

#include <stdio.h>

int n;


{

n=sizeof(int);

printf("Tamsayi uzunlugu: %d",n);

}




Örnek bildirimler;

int n;

long int sonuc;

short int yas, boy;

unsigned int agirlik;

Gerçel sayı

C programlama dilinde “float” ile temsil edilen veri tipi tek duyarlı gerçel sayıların

ifade edilmesini sağlar.

Gerçel sayı kayan noktalı (floating point) gösterimle bellekte saklanır. Aynı zamanda

standart C’ de “double” ile temsil edilen çift duyarlı ve “long double” ile temsil

edilen uzun çift duyarlı kayan nokta gösterimli gerçel sayılar da mevcuttur.

Program satırlarında gerçel sayılar 1234.5 veya 0.12345E+4 (=0.1234510+4

)

biçiminde yazılabilirler.

Duyarlılık hesaplanırken sayındaki nokta solunda sıfır kalacak şekilde kaydırılır ve

noktadan sonraki belirli sayıdaki nokta duyarlılık olarak belirtilir. Tek duyarlı bir

gerçel sayının duyarlılığı 6 hane ise 123.456789 sayı için duyarlılık aşağıdaki şekilde

belirlenir;

123.456789 0.123456E+3 {duyarlılık rakamları .123456 dır.}

Gerçel sayılar da bellekte derleyiciye bağlı bir büyükte yer işgal eder. Genelde tek

duyarlılık için 4 byte ve çift duyarlılık için 8 byte büyüklük kullanılmaktadır.

C derleyicilerinde genelde tek duyarlılık için duyarlılık 6 hane ve üs E-38 ile E+38

arasında ve çift duyarlılık için duyarlılık 15 hane ve üs E-308 ile E+308 arasındadır.

Gerçel sayılar için de derleyicinin kullandığı veri tipi uzunluğunu byte olarak sizeof

operatörü ile öğrenebiliriz.




Örnek bildirimler;

float x, y;

double oran;

Söz dizisi (string)

Bir metinin tamamını, herhangi bir cümlesini, bir sözcüğünü veya hecesini bellekte

tutmak için söz dizisi (string) veri tipi kullanılır.

C/C++ dilinde söz dizisi (string) karakter dizisi bildirilerek yapılır. Bir söz dizisi ilk

karakterden başlar ve sonlandırma karakterine (NULL: ASCII kodu 0) kadar devam

eder.

Örnek bildirimler;

char Ad[10]; /*en fazla 9 karakterli söz dizisi*/

char Soyad[15]; /*en fazla 14 karakterli söz dizisi*/

Dizi/Matris

Dizi aynı tipten verilerin tek bir isim altında bellekte tutulması için kullanılan bir veri

tipi yöntemidir.

Bu veri tipi ileriki konularda uygulama örnekleri ile detaylı olarak ele alınacaktır.

Örnek bildirimler;

int N[10];

int index[100];

int xyz[10][10][20];

float graf[20][10];

C/C++ da değişken bildirim yerleri ve tipleri

Bir C/C++ programında kullanılacak değişkenler önceden bildirilmelidir.

Değişkenlerin nerede bildirildiği oldukça önemlidir. Daha öncede belirtildiği gibi bir

C/C++ programı, bir yada daha çok fonksiyonun bir araya gelmesi ile oluşur.




Eğer bir değişken, programdaki fonksiyonların çoğunda kullanılacaksa genel (global)

olarak, yalnızca tek bir fonksiyon içinde kullanılacaksa o fonksiyon içinde yerel

(local) olarak bildirilmesi uygundur.

Yerel(local) bildirim

Yerel (local) değişkenler kullanıldığı fonksiyon içerisinde bildirilir ve yalnızca

bildirildiği fonksiyon içerisinde tanınır ve kullanılırlar. Bildirildiği fonksiyon dışında

tanınmazlar. Yerel değişkenler bildirildiği fonksiyon programın işlemesi sırasında

yürütüldüğü anda bellekteki veri alanında yer kaplarlar.

Yerel bildirim için örnek C/C++ programı;



{

int m,n; /* Yerel bildirim */

m=7;

n=kare(m);

printf("%d nin karesi=%d dir.",m,n);

}

int kare (k) /* Fonksiyon */

int k; /* Formal bildirim */

{

int gecici; /* Yerel bildirim */

gecici=k*k;

return gecici;

}

main() fonksiyonunun yerel değişkenleri olan m ve n, kare fonksiyonunun içinde

tanınamayacağından kullanılamazlar. Görüldüğü gibi m kare() fonksiyonuna

gönderilmekte ve kare() fonksiyonunda ise gönderilen m’ in değeri k adlı değişkende

tutulmaktadır. kare() fonksiyonunun yerel değişkeni ise gecici’ dir.

Genel(global) bildirim

Genel (global) değişken bütün fonksiyonların dışında bildirilir. Bir değişken bütün

program boyunca sürekli kullanılıyor ise genel olarak bildirilmelidir. Böyle bir

değişken yerel olarak bildirilirse, kullanılacağı her fonksiyona gönderilmesi gerekir.

Bu da gereksiz parametre aktarımına sebep olur.

Yukarıdaki örneği genel (global) değişken kullanarak tekrar yazar isek;





int m,n; /* Genel bildirim */

void kare(void); /* Fonksiyon bildirimi */


{

m=7;

kare();

printf("%d nin karesi=%d dir.",m,n);

}

void kare(void) /* Fonksiyon */

{

n=m*m;

}

Her iki program da aynı işi yapmaktadır. Fakat ikinci yazımda değişkenler genel

bildirilmiştir. Bu sebeple kare() fonksiyonuna ne parametre gelmekte ne de sonuç

gönderilmektedir. Çünkü genel değişkenler bütün fonksiyonlar içinde kullanılabilirler.

kare() fonksiyonunun tipi return ile bir şey gönderilmediği için main() fonksiyonu gibi

hiçbir şey anlamında void’ dir.

Formal bildirim

C/C++ programlarında bir fonksiyonun argümanı olabilir. Bunlara formal

parametreler denilmektedir. Bu argümanlar da uygun bir şekilde bildirilmelidir. Bunlar

yerel değişkenlere benzerler ve sadece fonksiyon içerisinde tanınırlar. Bildirimi

fonksiyon adının hemen altında veya fonksiyon parantezi içindeki argümanın önünde

yapılabilir.

Örneğin;

…

int fonk(m,n) /* Fonksiyon */

int m,n;

{

….

}

Veya;

…

int fonk(int m, int n) /* Fonksiyon */

{

….

}




Formal parametreler fonksiyona değer aktarımı yapılacağı zaman kullanılır.

Diğer bildirimler

Dışsal (Extern) Bildirim: Büyük programlar uygun olarak parçalara bölünüp ayrı ayrı

yazılıp derlendikten sonra birbirleri ile bağlantıları (link) kurulabilir. Ortak genel

(global) değişkenler bu program parçaların birisinde normal olarak bildirilirken, diğer

program parçalarında dışsal (extern) olarak bildirilir. {int x; extern int x; /*genel*/}

Statik (Static) Bildirim: Yerel değişkenler bildirildiği fonksiyon yürütüldüğü anda

bellekte yer kaplar. Fonksiyon sonlandığında boş bellek alanı gibi düşünülür ve yerel

değişkenin tutuğu değer kaybolur. Yerel değişkenin tutuğu eski değer korunsun istenir

ise yerel değişken bildiriminin önüne static anahtar sözcüğü yazılmalıdır. {int k;

static int k; /*yerel*/}

Saklayıcı tipi (Register) Bildirim: Bir değişken için bellek hücresi yerine işlemci

saklayıcısı (register) kullanılmak isteniliyor ise bu değişken saklayıcı tipte

bildirilmelidir. Bunun için değişken bildiriminin önüne register anahtar sözcüğü

yazılmalıdır. Saklayıcı tipi değişkenlere -işlemci registerleri kullanıldığı için- erişim

daha hızlı olur. Fakat kullanılabilecek saklayıcı tipi değişken sayısı sınırlıdır. {int a;

register int a;}

vb..

3.4.4. Değişkenlere başlangıç değeri atanması

Herhangi bir biçimde bildirilen bir değişkenin değeri o anda bellek hücresinde bulunan

kullanılması uygun olmayan rasgele bir değerdir. Değişkenler bildirilirken istenilen bir

başlangıç değeri atanabilir.

Örneğin;

…

char kr=’B’, y=41; /*41 ASCII tabloda A karakteri*/

int m=1, n=10, p;

float f=10.115, x;

…

3.4.5. C/C++ da sabit bildirimi




Sabitler de değişkenler gibi bellekte verinin saklandığı hücrelere verilen sembolik

adlardır. Değişkenden farklı olarak bildirilirken verilen değerler programın

yürütülmesi süresince değiştirilemez.

C dilinde sabit bildirimi, başlangıç değeri verilen değişken bildirimi gibi yapılır. Fakat

veri tipinin önüne const anahtar sözcüğü koyulmalıdır. Örneğin;

o const float pi = 3.142857;

o const int c = 5;

o const double e = 2.71828182845905;

3.5. Operatörler

Operatörler, değişkenler ve sabitler üzerinde matematiksel, karşılaştırma ve mantıksal

işlemlerin yapılmasını sağlayan işlemcilerdir. Operatörler bakımından en zengin

dillerden biri C/C++ dilidir.

3.5.1. Aritmetiksel operatörler

Değişkenler ve sabitler üzerinde temel aritmetik işlemleri gerçekleyen operatörlerdir.

C/C++ dilinde bulunan aritmetiksel operatörler;

o + : toplama

o - : çıkarma

o * : çarpma

o / : bölme

o % : modül adını taşıyan bölme işleminde kalanı verir

o -- : bir azaltma

o ++ : bir artırma

int a,b,c;

a=10; /*a değişkenine 10 sayısı*/

b=5; /*b değişkenine 5 sayısı */

c=a+b; /*c değişkenine 15 sayısı*/

printf(“%d C’nin değeri : \n”, c ); /*ekrana 15 yazılır*/

c++; /*c’nin değeri 1 artırılır*/


c--; /*c’nin değeri 1 eksiltilir*/


Aritmetik işlemler için örnek C/C++ programı;

#include <stdio.h>

void main(void)




{

int m=10, n=2, t,a,a2,b;

t=m+n;

a=m++; /*once a=m sonra m=m+1*/

a2=--m; /*once m=m-1 sonra a2=m*/

b=m/2;

++m; /*m=m+1*/

printf("m=%d, t=%d, a=%d, a2=%d, b=%d,",m,t,a,a2,b);

}

#include <stdio.h>

main()

{

int x, y;

x=10;

y=3;

printf(“%d”,x/y); /*ekrana 3 yazdırılır*/

printf(“%d”,x%y); /*ekrana 1 yazdırılır*/

x=1;

y=2;

printf(“%d %d”,x/y, x%y); /*ekrana 0 1 yazdırılır*/

Return 0;

}

Aritmetiksel operatörler

// Haftalık gelirinizi hesaplar

#include <stdio.h>

main()

{

float weekly, yearly;

printf( “Yıllık gelirin nedir?’\” ); // kullanıcıya mesaj

scanf(“%f ”,&yearly);

Weekly= yearly/52; // Haftalık gelir hesaplanır

printf(“\n\n Haftalık geliriniz %.2f YTL”, weekly);

Return 0;

}

Yıllık gelirin nedir? 38000.00

Haftalık geliriniz 730.77 YTL

C programlama dili önce çarpma, bölme ve mod işlemlerini, daha sonra toplama ve çıkarma

işlemlerini gerçekleştirir. Bu bizim ilk okulda öğrenmediğimiz işlemlerdir.

İlişkisel (karşılaştırma) operatörler




İki değişken veya sabit araşındaki ilişkiyi ortaya koymak için kullanılır. İlişkisel operatörler

aynı tipten olan değişken veya sabit değerleri birbirleri ile karşılaştırmak için kullanılırlar.

İlişkisel operatörleri, genel olarak, döngü deyimlerinde dönme koşulu ifadesi veya

karşılaştırma deyimlerinde koşul ifadesinde kullanılır. C/C++ programlama dilinde bulunan

ilişkisel operatörler;

o > : büyük

o >= : büyük eşit

o < : küçük

o <= : küçük eşit

o == : eşit

o != : eşit değil

İlişkisel operatörler C/C++ dilinde sayısal, karakter ve mantıksal değerler üzerinde kullanılır.

Söz dizisi (string) için kullanılmaz {bu amaçla strcmp() gibi kütüphane fonksiyonları

mevcuttur}.

İlişkisel işlemler için örnek C/C++ kodu;

…

if (x<15) ...

if(z==12) …

if(x<=y) …

…

İlişkisel operatörler sırası ile <, >, <=, >= ve ==, != öncelik sırasına sahiptir.Ayrıca ilişkisel

operatörler aritmetik operatörlerden öncelik sırası olarak sonra gelir.

C programlama dilinde ilişkisel operatörlerin ürettiği değerler koşul sağlanması durumunda 1,

sağlanmaması durumunda 0 (int) değeri üretir.

Örnek 1

a=5;

b=4;

c=b<=a; /* c=1 */

c=a!=b; /* c=1 */

c=b>a; /* c=0 */

Örnek 2

a=10;

b=5;

c=a<b+3;




Burada b+3 8

a<8 0

c=0 olur.

Genellikle if vb fonksiyonlarla kullanılırlar

Mantıksal operatörler

Mantıksal operatörler genel olarak birden çok karşılaştırma ifadesinin birleştirilip tek

bir koşul ifadesi haline getirilmesi veya koşulun tümleyenini (değil) almak için

kullanılır.

C/C++ dilinde bulunan mantıksal operatörler;

o && : ve (and)

o || : veya (or)

o ! : değil (not)

Ve mantıksal işlemci

İki veya daha fazla koşulun birleştirilmesinde kullanılır. Koşulların tamamı doğru ise sonuç

doğru, diğer durumlarda sonuç yanlıştır.

Koşul 1 Koşul 2 Koşul 1 ve koşul 2

0 0 0

0 1 0

1 0 0

1 1 1

Örneğin babanız size 1700 TL lik bir bilgisayar almak istiyor. Size diyorki, benim Ali’ den

1000 Tl, Veli den de 750 TL alacağım var. Ali ve Veli borçlarını öder ise sana bilgisayar

alıyorum. Burada (ve) mantıksal operatörü kullanıldığından her ikisinin borcunu ödemesi

durumunda ancak bilgisayar alınabilecektir. Birinin ödemesi veya hiç birinin ödememesi

durumunda bilgisayar alınmayacaktır. İki koşul için dört farklı durum olabilir.

Ali’nin ödeme

durumu

Veli’nin ödeme

durumu

Eldeki

para

Koşul 1 ve koşul 2

Ödemedi(0)-0TL Ödemedi(0)-0 TL 0 TL Alınmıyor(0)

Ödemedi(0)-0 TL Ödedi(1)-750 TL 750 TL Alınmıyor(0)

Ödedi(1)-1000 TL Ödemedi(0)-0 TL 1000 TL Alınmıyor(0)

Ödedi(1)-1000 TL Ödedi(1)-750 TL 1750 TL Alınıyor(1)




Veya mantıksal işlemci

İki veya daha fazla koşulun birleştirilmesinde kullanılır. Koşulların tamamı yanlış sonuç

veriyorsa yanlış diğer durumlarda doğru sonuç verir.

Koşul 1 Koşul 2 Koşul 1 veya koşul 2

0 0 0

0 1 1

1 0 1

1 1 1

Örneğin babanız size 1700 TL lik bir bilgisayar almak istiyor. Size diyorki, benim Ali’ den

1700 Tl, Veli den de 1750 TL alacağım var. Ali veya Veli borçlarını öder ise sana bilgisayar

alıyorum. Burada (veya) mantıksal operatörü kullanıldığından en az bir tanesinin borcunu

ödemesi durumunda bilgisayar alınabilecektir. hiç birinin ödememesi durumunda bilgisayar

alınmayacaktır. İki koşul için dört farklı durum olabilir.

Ali’nin ödeme

durumu

Veli’nin ödeme

durumu

Eldeki

para

Koşul 1 ve koşul 2

Ödemedi(0)-0TL Ödemedi(0)-0 TL 0 TL Alınmıyor(0)

Ödemedi(0)-0 TL Ödedi(1)-1750 TL 1750 TL Alınıyor(1)

Ödedi(1)-1700 TL Ödemedi(0)-0 TL 1700 TL Alınıyor(1)

Ödedi(1)-1700 TL Ödedi(1)-1750 TL 3450 TL Alınıyor(1)

değil mantıksal işlemci

bir koşulun gerçekleşmesi durumunda sonuç yanlış, gerçekleşmemesi durumunda ise sonuç

doğrudur.

Koşul 1 Değil(Koşul 1)

0 1

1 0

Örneğin babanız size 1700 TL lik bir bilgisayar almak istiyor. Size diyorki, benim Ali’ ye

1700 Tl, borcum var, ali benden borcunu istemez ise sana bilgisayar alacağım. Eğer AAli

parasını ister ise, baba da bara kalmayacağı için size bilgisayar alamayacaktır. Parasını

istememesi durumunda babada 1700 TL olacağından dolayı bilgisayar alınabilecektir.

Ali’nin parasını

isteme durumu

Eldeki para Koşul 1 ve koşul 2




istemedi(0)-0TL 17000 TL Alınıyor(0)

istedi(1)-1700 TL 0 TL Alınmıyor(1)

Mantıksal operatörler için örnek C/C++ kodu;

…

if (x<15 && 20<y)

…

if (!(m<5))

…

Öğrenci başarılarını değerlendirirken ve mantıksal operatörüne ihtiyaç duyulacaktır. DD notu

için öğrencinin başarı notunun 50 den büyük eşit ve 56 dan küçük olması gerekir. Bu

durumda programda aşağıdaki şekilde bir koşul ifadesi dd sınıfını belirler

if( Basari_notu>=50 && Basari_notu<57)

Printf( “ notunuz dd dir”);

3.5.4. Bit düzeyinde işlem yapan operatörler

Bit düzeyinde işlem yapmak, bir tamsayı veya karakter değişkenin değeri yerine

doğrudan bitler (0,1) üzerinde sınama, değiştirme veya öteleme/kaydırma (shift)

yapmak için kullanılır.

Örneğin, bilgisayarın iletişim kanalından alınan 8 bitlik bir kısa tamsayının düşük

öncelikli üçüncü bitinin ne olduğunu öğrenmek istiyorsak bu operatörleri kullanmamız

gerekir.

Bu operatörler, kullanıcıya işlemcinin birleştirici dili (assembly) düzeyinde, bitler

üzerinde çalışma olanağı verir.

C/C++ dilinde bulunan bit düzeyinde işlem yapan operatörler;

o & : bit düzeyinde ve (bitwise and)

o | : bit düzeyinde veya (bitwise or)

o ^ : bit düzeyinde ya da (bitwise xor)

o ~ : bir’e tümleme (one’s complement)

o << : sola kaydırma (shift left)

o >> : sağa kaydırma (shift right)

3.5.5. Diğer operatörler




Atama operatörleri: bir değişkene bir bağıntının sonucunu veya bir değeri eşitlemek

için kullanılırlar. C/C++ dilinde bulunan temel basit atama operatörü “=” dir. Ayrıca

C/C++ dilinde aşağıda verilen diğer bitişik operatörler de kullanılabilir;

o += : ekleyerek atama {t+=m+n t=t+(m+n)}

o -= : çıkararak atama {t-=m+n t=t-(m+n)}

o *= : çarparak atama {t*=m+n t=t*(m+n)}

o /= : bölerek atama {t/=m+n t=t/(m+n)}

o %= : bölüp kalanını atama {t%=m+n t=kalan(t/(m+n))}

o <<= : sola öteleyerek atama

o >>= : sağa öteleyerek atama

o &= : bit düzeyinde ve işlemi yaparak atama

o |= : bit düzeyinde veya işlemi yaparak atama

o ^= : bit düzeyinde ya da işlemi yaparak atama

o ~= : bir’e tümleme işlemi yaparak atama

? karşılaştırma operatörü: C/C++ dilinde if-else karşılaştırma deyiminin yaptığı işi

sınırlı olarak yapan bir operatördür. Genel yazılım biçimi;

o (koşul deyimi) ? deyim1 : deyim2

o Örnek 1: {m = (a>b) ? a : b; a>b ise m=a, değilse m=b}

o Örnek 2: {(m>5) ? a++ : b++; m>5 ise a=a+1, değilse b=b+1}

& ve * işaretçi operatörleri: İşaretçi, bir değişkenin bellekteki adresidir. İşaretçi

değişken bu adresin saklanacağı özel bir değişkendir. Bu tip değişkenlere yalnızca

bellek adresleri veya diğer işaretçi değişkenler atanabilir. İşaretçiler önümüzdeki

dönem verilecek olan C programlama dersinde detaylı olarak verilecektir. Burada

sadece bu operatörlerin C/C++ dilinde bildirimini ve kullanımını gösteren basit bir

örnek program verilecek;

#include <stdio.h>

void main(void)

{

int *p,*q, n=5, m=10, g;

g=n;

p=&n; /* n 'nin adresi p' ye ataniyor */

q=&m; /* m 'nin adresi q' ye ataniyor */

*p=m; /* adresi p ile gösterilen yere (yani n) m' in degeri ataniyor */

*q=g; /* adresi q ile gösterilen yere (yani m) g' in degeri ataniyor */

clrscr();

printf("p=%p,n=%d,q=%p,m=%d",p,n,q,m);

}

sizeof operatörü: daha önce de örnek ile bahsedildiği gibi bir değişkenin veya veri

tipinin bellekte kaç byte yer kapladığını verir.




Örnekler: {sizeof a, sizeof (int), vb.}

3.5.6. İşlem öncelikleri

C/C++ dilinde yazılan işlemlerin istenildiği şekilde doğru olarak sonuçlana bilmesi

için ifadeler işlem öncelikleri dikkate alınarak yazılmalıdır.

Aşağıdaki tabloda operatörlerin C/C++ dilindeki öncekikleri görülmektedir. Ayrıca

aynı önceliğe sahip operatörlerin peşi sıra yazılması halinde hangisinin ilk önce

değerlendirileceği de aynı tabloda görülmektedir {Bu operatörlerden “->”, “.”, vb.

bahsedilmeyen bir kısmı C Programlama dersinde yeri geldiğinde detaylıca ele

alınacaktır};

Öncelik Operatörler (peşi sıra: soldan sağa)

En çok ( ) [ ] -> .

sizeof (type) & * -- ++ ~ !

*: çarpma / %

+ -

<< >>

< <= > >=

. == !=

. &: ve

. ^

|

&&

||

?:

>>= <<= |= ^= &= %= /= *= -= += =

En az ,

3.5.7.Matematiksel bağıntılarda veri tipi dönüşümleri

C/C++ dilinde yazılan bir matematiksel bağıntı içinde bir çok değişken ve sabit

bulunabilir. Bu değişken ve sabitler birbirlerinden faklı tiplerde bildirilmiş olabilir.

Bu durumda hesap sonucunun hangi tipte olacağı önemlidir ve bu sonuç için bildirilen

tipe uygun olması veri kaybını önler. Örneğin sonucu “float” olan bir işlem “int”tipi

bir değişkene atanır ise sadece tam kısmı korunur ve ondalık kısmı ihmal edilir. Bu tür

işlemler kontrolsüz yapılır ise değer kaybına neden olabilir.




Bir işlem sırasında ilgili operatörün (işlem önceliklerine göre işleme sokulan) iki değer

(değişken veya sabit) üzerinde işlem yapacağını dikkate almalıyız.

İşlem sırasında verilerden birinin tipi aşağıdaki tabloda verildiği önceliğe göre

dönüşüme tabi tutulur {UYARI: değişime uğrayan sadece değerdir. Asıl değişken

kendi tip değerini korur};

Öncelik Dönüştürülecek değer

En çok “long double”

“double”

“float”

“unsigned long int”

“long int”

“unsigned int”

En az “int”

Örneğin, bir “long double” ile diğer tipte bir veri işleme girecekse diğerinin tipi “long

double” ‘ a dönüştürülür ve işlem sonuçu “long double” olur.

Her iki değer de bir tip tamsayı ise, tiplerden biri veya her ikisi her ikisini de

gösterebilecek tamsayı tipine dönüştürülür {derleyiciye göre dönüşüm farklı olabilir}.




Giriş çıkış komutları.

Giriş çıkış işlemleri her programda ihtiyaç duyulan temel işlemlerden birisidir.

Programcı veya diğer veri kaynakları ile bilgisayarın iletişimini sağlar.

C/C++ programlama dilinde giriş çıkış işlemleri bu dilin giriş çıkış kütüphane

fonksiyonları (fonksiyon kavramı daha ileriki derslerde geniş olarak ele alınacaktır)

aracılığı ile gerçekleştirilir.

C/C++ programlama dilinde ihtiyaç duyulan her türlü giriş çıkış işlemi bu kütüphane

fonksiyonları ile kolay ve esnek bir şekilde sağlanabilmektedir.

Bir C/C++ programında standart giriş çıkış fonksiyonları oldukça çok kullanılır. Bu

giriş çıkış fonksiyonlarını kullanabilmek için “stdio.h” adlı başlık dosyasını aşağıdaki

şekilde yazarak program içine koymalıyız;

#include <stdio.h>

Dersimizin bu kısmında sadece temel giriş çıkış fonksiyonlarından örnekler ile

bahsedilecektir. Ders kapsamında ihtiyaç duyulan diğer giriş çıkış fonksiyonlarına

ilgili yerlerde değinilecektir. Ayrıca giriş çıkış formatlama kavramına da ileriki

konularda değinilecektir.

3.6.1.Temel giriş çıkış işlemleri

Temel giriş çıkış işlemleri, karakter söz dizisi ve sayısal veri türlerinin standart giriş

çıkış birimlerine aktarılmasını ifade eder. Örneğin bir karakterin klavyeden okunması

veya sayının ekrana yazdırılması bu tür temel giriş çıkış işlemlerindendir.

scanf()- printf() temel giriş çıkış fonksiyonları:

Bu fonksiyonlar, genel olarak formatlı okuma (scanf) ve yazma (printf) işlemlerinde

kullanılan, her türlü verinin okunup yazılabileceği oldukça esnek giriş çıkış

fonksiyonlarıdır.

Örnekler;

scanf(“%f”,&x); /*x: gerçel sayı*/

scanf(“%d”,&y); /*z: tamsayı*/

scanf(“%c”,&kr); /*kr: karakter*/

printf(“vize notu: %d”, vize); /*vize: tamsayı*/

printf() Fonksiyonu




Sayısal ve alfanümerik değerleri ekrana(standart çıkış birimine) göndermek için kullanılan

formatlı çıkış fonksiyonudur. Bu fonksiyon stdio.h kütüphanesi içerisinde tanımlıdır. Daha

önce bahsettiğimiz gibi stdio.h başlık dosyasının programın başına eklenmesi gerekir.

printf (parametreler)

Karakter dizini ekrana yazdırmak istiyorsak

printf (“Merhaba Millet”) // “Merhaba Millet” ekrana yazdırılır.

printf (“b=100”) // “b=100” string değeri ekrana yazdırılır.

……

int b=10;

printf(“ b değeri = %d dur”,b); // “b değeri = 10 dur” ekrana yazdırılır.

………

printf("p=%p,n=%d,q=%p,m=%d",p,n,q,m); /*p,q: tamsayı işaretçi, n,m: tamsayı*/

Printf(“ %c %c %c”, ‘a’, ’b’, ‘c’);

Printf(“ Ben Cemil, ben %d yaşındayım ve maaşım %f YTL\n”, 37, 1000.10)

Ben Cemil, ben 37 yaşımdayım ve maaşım 1000.10 YTL




Bilinen kontrol karekterleri(Common Escape Sequences )

Character Escape Sequence

\a zil sesi(beep)

\b Geriye boşluk(Backspace )

\f Kağıt besleme

\n Bir satır ekle(Newline)

\r Enter (Return)

\t Sekme(Tab )

\\ Ters slash (Backslash)

\‘ Tek tırnak(Single quotation mark )

\“ Çift tırnak(Double quotation marks )

.

.

\xdd 16 sayı sisteminde gösterim(Hexadecimal notation )




4. YAPISAL PROGRAMLAMA KAVRAMI.

Yapısal programlama, program tasarımı ve yazılmasını kurallara bağlayan ve disiplin

altına alan bir yaklaşımdır.

Yapısal programlamada problem çözümü daha kolay alt problemlere (modül) bölünür.

Her bir alt problem (modül) daha düşük seviyedeki alt seviyelere bölünür.

Bu işlem, aşağıdaki şekilde de görülebileceği gibi her bir modülün kolaylıkla

çözülebileceği seviyeye kadar devam eder.

Yapısal programlama, program tasarımı ve yazılmasını kurallara bağlayan ve disiplin

altına alan bir yaklaşımdır.

Yapısal programlamada problem çözümü daha kolay alt problemlere (modül) bölünür.

Her bir alt problem (modül) daha düşük seviyedeki alt seviyelere bölünür.



En üst seviyede çözümün ana mantığının sergilendiği ana modül yer alır. Alt

seviyelere indikçe izlenecek adımlar ile ilgili ayrıntılar artar.

Modüler program tasarımında her modül diğerlerinden bağımsız olmalıdır. Kontrol

her modüle bir üst seviyedeki modülden geçmeli ve modül işlendikten sonra tekrar

ayın modüle iletilmelidir.

Modüllerin tanımlanmasında, (algoritma parçası olduğu için) sözde kod (pseudo-code)

kullanılır.




Bir modülün çözümünde kullanılacak algoritma, sözde kod ile ifade edilirse programa

geçiş büyük ölçüde kolaylaşır.

Örnek 1;

Problem: 1’den n’ ye kadar olan tam sayıların toplamını bulmak.

Problem çok kolay olmasına rağmen modüler programlamaya bir örnek olması açısından

aşağıdaki şekilde bir tasarım düşünelim;

Tasarlanan ana modül ve üç alt modülü sözde kod ile;

/* Ana modül */

Veri

Hesapla

Yaz

/* Veri modülü */

n değerini oku

/* Hesapla modülü */

Eğer n<=0 ise

n değerinin geçersiz olduğunu yaz

değilse

i’ ye 1 değerini yükle

toplam’a 0 değerini yükle

i<n olduğu sürece

i’ yi toplama ekle

i’ yi artır.

/* Yaz modülü */

toplam’ ı yaz

Bu aşamadan sonra algoritma herhangi bir programlama dili ile yazılabilir.

Problemin C/C++’ ta örnek kodlanması (fonksiyon kavramına ileri konularda değinilecek);

#include <stdio.h> /*standart giris cikis icin*/




#include <conio.h> /*DOS destekli giris cikis icin*/

int veri ();

float hesapla (int);

void yaz (float);

void main(void) /* Ana modul */

{int n;

float toplam;

clrscr();

n=veri();

toplam=hesapla(n);

yaz(toplam);

}

int veri() /* Veri modulu */

{int n;

printf("1' den N' ye kadar olan tam sayilarin toplamini bulma programi");

printf("\n");

printf("\n");

printf("N degerini giriniz: ");

scanf("%u",&n);

return n;

}

float hesapla (int n) /* Hesapla modulu */

{int i;

float t;

t=0;

for(i=1;i<=n;i++) t=t+i;

return t;

}

void yaz (float toplam) /* Yaz modulu */

{

printf("\n");

printf("sonuc=%0.0f",toplam);

getch();

}

4.1. Yapısal programlamada algoritma temel yapıları: sıra, sorgu ve tekrar yapıları.

Yapısal programlamada ana ilke goto deyimini kaldırmak ve temel kontrol yapılarını

kullanmaktır. Yapısal olmayan bir programda çok sayıda goto deyimi kullanılır ve

yukarıdan aşağıya, aşağıdan yukarıya atlamalar görülür.

Program içinde birkaç atlamadan sonra programcı, işlem akışını ve program mantığını

izleyemez duruma gelir.

Yapısal programlamada her hangi bir algoritma üç temel kontrol yapısı ile ifade

edilebilir;

o Sıra: bir dizi işlemin birbiri ardından sırasıyla yapılmasını ifade eder.




o Sorgu (seçme): iki seçenek yoldan hangisinin izleneceği bir testin sonucuna

bağlıdır.

o Tekrar (yineleme): test edilen sonuç sağlanana kadar işlemin yinelendiği

durumu ifade eder.

Bu temel kontrol yapıları aşağıda grafiksel olarak (akış diyagramı) gösterilmiştir;

4.1.1. Sıra yapısı

En basit akış şeması ifadeleri, bir dizi işlemin birbiri ardından sırasıyla yapılmasını

şeklinde olan akış ifadeleridir. Bu tip akışlar oldukça yalın ve basittir.

Bu tarz akışlar genelde bir problemin bir parçasını çözümlemek ve ifade etmek için

kullanılır.

Sorgu ve tekrar gerektirmeyen bazı basit ardışık problemler de bu tip akış kullanabilir.

Örneğin;

Klavyeden girilen iki sayıyı okuyup aritmetik ortalamasını hesaplayan ve sonucu

ekrana yazan bir programın akışı aşağıdaki şekilde ifade edilebilir;




4.1.2. Sorgu (seçme) yapıları

Algoritma içerisinde verilen işlem adımları genel de sıralı adımlardan oluşur. Fakat

bazı koşullarda bu işlem sıralarının değiştirilmesi ve diğer bir işlem sırasının seçilmesi

gerekebilir.

Sorgu (seçme) işlemi akış diyagramında baklava dilimi şeklindeki karşılaştırma

simgesi ile ifade edilir. Simgenin içerisine koşul yazılır. Koşulun sonucuna göre iki

yönden birisi seçilir. Program akışı, koşul olumlu ise “evet” olumsuz ise “hayır”

olarak etiketlenen yöne dallanma yapar.

4.1.2.1. Basit Sorgu (IF) yapısı.

Bir koşullu işlem yapma deyimidir. “if” ve “else” tek bir karşılaştırma deyimi olup

“else” ’in kullanımı isteğe bağlıdır. Eğer koşul olumlu ise “if” ’den sonraki komut

kümesi yürütülür ve “else” ’den sonraki komut kümesi atlanır. Eğer koşul olumsuz ise

“if” ’den sonraki komut kümesi atlanır ve “else” ’den sonraki komut kümesi

yürütülür.

Aşağıda verilen şekilde “else” ’li ve “else” ’siz “if” yapısı akış diyagramı olarak

gösterilmekte ve genel yazılım formatı verilmektedir;




Örnek: Örnek alg.3 için çizilen akış diyagramı için if sorgu yapısı kullanan bir C/C++

programı yazalım.




Örneğin C/C++’ ta kodlanması (goto kullanılarak);

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int main(int argc, char *argv[])

{

float a,x,e,b,y;

printf("karekoku bulunacak sayiyi giriniz: ");

scanf("%f",&a);

printf("\n");

printf("tahmini karekoku giriniz: ");

scanf("%f",&x);

printf("\n");

printf("kabul edilebilir hatayi giriniz: ");

scanf("%f",&e);

printf("\n");

printf("\n sayi Tahkök hata b y ");

printf("\n-------------------------------------------------------");

printf("\n %f, %f, %f, %f, %f ",a,x,e,b,y);

A4:

b=(a-x*x)/(2*x); /* fark (hata) değeri olan b' yi hesapla */

y=x+b; /* daha yakın yeni karekök değerini (y) hesapla */

printf("\n %f, %f, %f, %f, %f ",a,x,e,b,y);

if (fabs(b)<=e) goto A9; /* eger mutlak(b)<=e ise iterasyonu durdurmak için A9 a git */

else x=y; /* y yeni karekök degerini x degiskenine ata */

goto A4; /* islemi yeni x tahmini ile tekrarlamak için A4'e git */

A9:

printf("\n-------------------------------------------------------");

printf("\n karekok=%f \n\n",y); /* en son hesaplanan karekök değerini (y) ekrana yaz */

system("PAUSE");

return 0;

}




Yapısal programlamada istenmemesine rağmen örnek problemde döngü olduğu ve “if” yapısı

tek başına döngü işlemini yapamadığı için “goto” komutunu kullandık. Ayrıca program çok

kısa olması nedeniyle modüler programlamaya ihtiyaç duymadık.

Örnek

Bir kreşe kayıt edilen öğrencilere yaşlarına göre öğretmen atayan bir program için algoritma

ve akış diyagramı tasarlayalım

Öğrenci 1 ile 3 yaş arasında ise, Pınar öğretmen

Öğrenci 4 yaşında ise, Aylin öğretmen,

Öğrenci 5 yaşında ise, Ceyda öğretmene, atanacak

Bu yaşların dışında bir yaş atanması durumunda ise “bu yaş için öğretmen yok” mesajı

verilecektir.

Adım 1: Başla

Adim 2: oku(Adi, Yas)

Adim 3: eğer yas>=1 ve yas<=3 ise yazdır(“Pınar öğretmen”)

Adim 4: eğer yas=4 ise yazdir(“Aylin Öğretmen”)

Adim 5: eğer yas=5 ise yazdir(Ceyda Öğretmen”)

Adim 6: yazdir(“Bu yaş için öğretmen yok”)

Adim 7: dur




Örnek: bir f(x) fonksiyonunun denklemi aşağıdaki şekilde verilmiştir. Bu fonksiyonun

hesaplanması için algoritma ve akış diyağramı gerçekleştiriniz.

Adım 1: Başla

Adim 2: oku(x)

Adim 3: eğer x<0 ise fx=1

Adim 4: eğer x>=0 ve x<=3 ise fx=x+1

Adim 5: eğer x>3 ise fx=4

Adim 6: dur

Başla

Adi,yas

3>=Yas>=1

Yas=4

Yas=5

“Aylin”

“Pınar”

“Ceyda”

“bu yaş için

öğretmen yok”

Dur




4.1.2.2. “switch - case” seçme yapısı

“switch” – “case” seçme yapısı bir değişkenin içeriğine bakarak programın akışını

birçok seçenekten birisine yönlendiren bir karşılaştırma deyimidir.

Değişkenin içeriği hangi sabit ile uyuşursa ona ait işlem kümesi ve arkasındaki bütün

işlem kümeleri yürütülür. Ancak küme deyimleri arasında break kullanılırsa, daha

sonraki tüm işlem kümeleri atlanarak “switch” bloğunun sonuna gidilir.

“switch” – “case” seçme yapısı akış diyagramı olarak aşağıdaki şekilde gösterilmekte

ve genel yazılım formatı verilmektedir;

Başla

x

x<0

0<=x<=3

x>3

Fx=x+1

Fx=1

Fx=4

Dur

evet

evet

evet

hayır

hayır




Örnek: “switch”– “case” seçme yapısı için örnek bir C/C++ programı;

#include <stdio.h>

#include <stdlib.h>


{

char a;

printf("\n 1-5 arasi bir rakam giriniz: ");

scanf("%c",&a);

switch (a) {

case '1': printf("cok zayif \n"); break;

case '2': printf("zayif \n"); break;

case '3': printf("orta \n"); break;

case '4': printf("iyi \n"); break;

case '5': printf("pekiyi \n"); break;

default: printf("yanlis secim \n");

}




system("PAUSE");

return 0;

}

Başla

a

a='1'

"çok zayıf"

Dur

evet

hayır

a='2'

" zayıf"

a='3'

" orta"

a='4'

" iyi"

a='5'

evet

evet

evet

evet

hayır

hayır

hayır

" Pek iyi"

hayır

" zayıf"




Break deyiminin önemi

#include <stdio.h>

#include <stdlib.h>


{

char a;


scanf("%c",&a);

switch (a)

{

case '0':

case '1':

case '2':

case '3': printf("cok zayif \n"); break;

case '4':


case '6':


case '8':




}

system("PAUSE");

return 0;

}




#include <stdio.h>

#include <stdlib.h>


{

char a;


scanf("%c",&a);

switch (a) {

case '1': printf("cok ");






}

system("PAUSE");

return 0;

}




Başla

a

a='1'

"çok "

Dur

evet

hayır

a='2'

" zayıf"

a='3'

" orta"

a='4'

" iyi"

a='5'

evet

evet

evet

evet

hayır

hayır

hayır

" Pek iyi"

hayır

" zayıf"




Tekrar(Döngü) Yapıları-C programlama dilinde Döngüler

Programlama dillerinin temel ifadelerinden biriside döngü ifadeleridir. Tekrar (döngü)

yapıları belirli bir kod parçasının farklı değerler üzerinde tekrar tekrar çalıştırılmasını sağlar.

kod uzuluğunu azaltmak başta olmak üzere iterasyon ile problem çözümü gibi uygulamalarda

sıklıkla döngü kurulması gerekmektedir. Bu döngü kurma işlemi, ya döngü deyimleriyle yada

programlamada ilke olarak kullanılması istenilmeyen goto deyimiyle gerçekleştirilir.

farklı döngü ifadeleri bulunmaktadır. Döngü ifadelerini ikiye ayırabiliriz; BİRİNCİSİ koşulu

başta sınayan, ikincisi ise koşulu sonda sınayan. Koşulu başta sınaması, daha çevrime

girmeden döngü koşuluna bakılması ve koşul olumlu ise çevrime girilmesi, koşul olumsuz ise

çevrime girilmeden sonraki adımlara geçilmesi anlamına gelir. Koşulun sonda sınanması ise,

çevrim içerisinde kodun en az bir kere işletilmesi ve eğer koşul sağlanıyorsa çevrime devam

edilmesi sağlanmıyor ise çevrimden çıkılması anlamına gelir.

FOR Döngüsü

Tekrar(döngü) ifadelerinin en bilineni "for" döngü ifadesidir. Döngü bloğu içerisinde verilen

ifadeleri, verilen koşulun doğru olduğu sürece tekrar, tekrar yürütmesini sağlar. Koşul

sınaması döngüye girilmeden önce yapılmaktadır. Dolayısı ile verilen koşul doğru sonuç

vermiyorsa döngü blogu ifadeleri yürütülmemektedir. “for” döngüsünde koşul sayacı ve “for”

koşul satırında üç parametre vardır. Birinci parametre döngü sayacına başlangıç değeri

verilmesi, ikinci parametre koşulu ve üçüncü parametre her çevrimde sayacın nasıl

artacağını/eksileceğini ifade eder. Döngüye girmeden önce sayaç bir başlangıç değeri alır ve

daha sonra koşula bakılır. Döngü içerisindeki işlemler yapıldıktan sonra sayaç üçüncü

parametrenin durumuna göre değiştirilir (artırılır/eksiltilir).

For döngüsünde genellikle, önceden kodun ne kadar tekrar edileceği bilinmektedir.

Şekil de görüldüğü üzere for döngüsü bir ifade içeriyorsa süslü parantezlere gerek yoktur.

Ancak döngü bloğu çok sayıda ifadeden oluşuyorsa, süslü parantezler içerisinde verilmelidir.

for blogunun sonunda (;) gerek yoktur.

sayaç artırım/azaltım ifadesi

Koşul ifadesi( döngü sonlandırma)

Sayaç başlangıç değeri




Şekil . for döngü yazılışı

Örnek yazılım formatları:

for (k=1;k<50; k+=2)

burada standar bir kullanım düzeni verilmiştir. sayaç değeri ikişer ikişer artmaktadır.

for (k=5;k<=n; k++)

bu kullanmda da standart bir kullanım düzeni verilmiştir. Ancak sayaç değeri 1 den

değil 5 sayısından başlatılmıştır.

for (x=50;x>10;x--)

Bu kullanımda ise sayac başlangıç değeri bitiş değerine göre daha büyüktür(x=50).

Böylece koşul ifadeesinde daha küçük (x>10) bir rakamdan büyük olması istenir iken

sayaç değeride döngüde azaltılmaktadır(x--).

for ( ;x<10;x++) /* başlangıç değeri daha önce atanmış olmalı */

Bu kullanımda başlangıç değeri verilmemiş. Başlangıç değerinin döngüye girilmeden

verlilmiş olması gerekir.örneğin;

x=0; gibi

for (x=2;x<n; ) /* x döngü sayacı döngü içinde değiştirilmeli */

Bu kullanımda artım ifadesi verilmemiş, artım ifadesi for deyimi blogunun içerisinde

verilmelidir. örneğin;

for (x=2;x<n; )

{

.....

x++;

}

for ( i=0; i<10; i++)

ifade ; tek ifade olması durumunda süslü

parantezlere ihtiyaç duyulmaz

for ( i=0; i<10; i++)

{ ifade1 ;

ifade2 ;

ifade3 ;

...

}

Birden fazla ifade yer alması durumunda.

Blok parantezlerine ihtiyac vardır.

Noktalı virgül konulmuyor

Noktalı virgül konulmuyor




Şekilde “for” döngü yapısı akış diyagramı altarnatifl formları gösterilmekte ve genel

yazılım formatı verilmektedir;

Örnek: “for” döngü yapısı için örnek bir C/C++ programı;

#include <stdio.h>

#include <conio.h>

void main(void)

{int i, n, faktoriyel=1;

clrscr();

printf("faktoriyeli alinacak sayiyi giriniz: ");

scanf("%d",&n);

for(i=1;i<=n;i++)

{

faktoriyel*=i; /* faktoriyel=faktoriyel*i */

} /* tek deyim oldugu icin parantezler kullanılmaya bilirdi */

printf("hesaplanan faktoriyel değeri = %d\n",faktoriyel);

getch();

}

WHILE Döngüsü

“while” döngüsü “for” döngüsü gibi aynı işlemleri birçok kez tekrarlamak için kullanılır. Bu

döngüde koşul sınaması for döngüsünde olduğu gibi çevrime girmeden yapılır. Koşul tek bir

karşılaştırmadan oluşabileceği gibi birden çok koşulun mantıksal operatörler ile birleştirilmesi

ile de oluşturulabilir. Şekilde “while” döngü yapısı akış diyagramı olarak gösterilmekte ve

genel yazılım formatı verilmektedir;




For döngüsü bir işi belli bir sayıda tekrarlamaya yaradığından döngü sayısı bellidir. while

döngüsü ise döngünün genellikle ne kadar tekrarlanacağı bilinmediği durumlarda kullanılır.

Şekil de görüldüğü üzere while döngüsü bir ifade içeriyorsa süslü parantezlere gerek yoktur.

Ancak döngü bloğu çok sayıda ifadeden oluşuyorsa, süslü parantezler içerisinde verilmelidir.

while blogunun sonunda (;) gerek yoktur.




Şekil . while döngü yazılışı

Örnek: “while” döngü yapısı için örnek bir C/C++ programı;

/* while örnek 1*/

#include <stdio.h>

#include <stdlib.h>


{

int sayac=1,n;

printf("kaca kadar sayalim: ");

scanf("%d",&n);




while(sayac<=n)

{

printf(" %d",sayac);

sayac++;

}

printf(" \n");

system("PAUSE");

return 0;

}

DO … WHILE Döngüsü

“do … while” döngüsü diğer döngüler gibi aynı işlemleri birçok kez tekrarlamak için

kullanılır. Farklı olarak, bu döngüde koşul sınaması döngü bloğunun sonunda gerçekleştirilir.

Dolayısı ile blok içerisindeki ifadeler koşun ister doğru ister yanlış sonuç üretsin bir defa

işletilir. Koşul tek bir karşılaştırmadan oluşabileceği gibi birden çok koşulun mantıksal

operatörler ile birleştirilmesi ile de oluşturulabilir.

Aşağıda verilen şekilde “do … while” döngü yapısı akış diyagramı olarak gösterilmekte ve

genel yazılım formatı verilmektedir;




Örnek: “do…while” döngü yapısı için örnek bir C/C++ programı yazalım;

#include <stdio.h>

#include <stdlib.h>


{

int sayi,kare;

do

{

printf("\nbir sayi giriniz: ");

scanf("%d",&sayi);

kare=sayi*sayi;

printf("sayinin karesi= %d\n",kare);

}

while(sayi>0);

printf("cevrim sonlandirildi \n");

system("PAUSE");

return 0;

}




4.1.3.4. Örnekler

Örnek 1: Girilen bir tamsayının tam kare olup olmadığını araştıran bir C/C++

programı yazalım.

Girilen bir sayının tam kare olabilmesi için, bu sayının karekökünün tam kısmı

alınarak elde edilen değerin tekrar karesi alındığında bu sayının ilk girilen sayıya eşit

olması gerekir.

Program ve akış diyagramı;

#include <stdio.h>

#include <stdlib.h>

#include <math.h>


{

int a,c,d;

float b;

printf("\nsayi giriniz: ");

scanf("%d",&a);

printf("\n");

b=sqrt(a);

c=fabs(b); /* int c degisgeni ne atandigi

icin mutlak b nin tam kismi

c ye ataniyor */

d=c*c;

if(a==d) printf("sayi tam karedir \n");

else printf("sayi tam kare degildir \n");

system("PAUSE");

return 0;

}




Örnek 2: Girilen a ve b sayıları 100’ den küçük ise c=a*a+b işlemini yapan bir C/C++

programı yazalım.

Yazılacak programda iki sayının 100 den küçük olması koşulu sorgulanacak. Bu koşul

sorgulaması tek tek karşılaştırma ilede yapılabilir fakat bu durumda iki ayrı “if”

yapısını iç içe kullanmak gerekir. Tek “if” yapısı kullanmak için iki koşul && (ve)

mantıksal operatörü ile birleştirilebilir.

Bu durumda oluşacak C/C++ program ve akış diyagramı;

#include <stdio.h>

#include <conio.h>

void main(void)

{

int a,b,c;

clrscr();

printf("a degerini giriniz: ");

scanf("%d",&a); printf("\n");

printf("b degerini giriniz: ");

scanf("%d",&b); printf("\n");

if(a<100&&b<100)

{c=a*a+b;

printf("c degeri = %d\n",c);}

else

printf("sayilardan en az biri uygun degil \n");

getch();

}

ÖDEV 2




Soru 2.1;

1 den n’ e kadar olan sayıların toplamını bulmak için “for”, “while” ve “do…while” döngü

deyimlerini kullanarak üç ayrı C/C++ programı yazınız. Bu programlardan birisi için akış

diyagramını çiziniz.

Soru 2.2;

Girilen n tamsayıdan negatif ve pozitif olanların sayısını bulan ve ekrana yazan bir C/C++

programı yazınız ve bu programın akış diyagramını çiziniz.

Soru 2.3;

Girilen n tamsayıdan istenilen bir tam sayıya en yakın olan sayıyı bulan ve ekrana yazan bir

C/C++ programı yazınız ve bu programın akış diyagramını çiziniz.

Soru 2.4;

Girilen bir sayının belirtilen üssünü alan ve ekrana yazan bir C/C++ programı (hazır

matematiksel fonksiyon kullanmadan) yazınız ve bu programın akış diyagramını çiziniz.

Soru 2.5;

Ödev 1, soru 1.1’ de oluşturduğunuz algoritma için bir C/C++ programı yazınız.

Soru 2.6;

Bir gemi 10 dakika boyunca düzgün hızlanarak hızını 0 mil/saat’ ten 40 mil/saat’ e çıkarıyor.

Daha sonra ulaştığı bu hızda 2 saat boyunca sabit hızla gidiyor. Ardından 20 dakika boyunca

düzgün yavaşlayarak duruyor. Herhangi bir t (dakika) anında geminin hızını veren C/C++

programı yazınız ve bu programın akış diyagramını çiziniz.

5. DİZİ (VEKTÖR) KAVRAMI




Değişkenler isimlendirilirken her bir değişken için bir ad kullanmak zorunludur. Bu

ise değişken sayısının çok olması durumunda uygun bir yöntem değildir. Bu durumda

benzer özelliklere sahip elemanları bir küme gibi düşünerek bu doğrultuda işlem

yapmak daha uygun olacaktır.

Belli özelliklere sahip bu elemanların oluşturdukları kümeler dizi (array) olarak

adlandırabilir.

Diziler, indisli değişkenler kullanılarak adlandırılırlar. Örneğin n elemanlı bir A dizisi

için A1, dizinin birinci elemanını ve An , dizinin son elemanını ifade etmektedir.

C programlamada, dizi adı herhangi bir geçerli değişken adı olabilir, fakat indis kare

parantez içine alınmalıdır.

Örneğin 10 elemanlı bir A dizisinin elemanları sırasıyla A[1], A[2], A[3],…, A[10]

şeklinde ifade edilir.

Dizi, art arda gelen aynı tip verileri saklayan bellek elemanları veya bellek hücreleri

olarak tanımlanabilir.

Dizi tanımlanırken diziye bir isim verilir. Dizi tanımlandıktan sonra programda bu

isimle çağrılır.

C/C++ programlama dillerinde dizi bildirimi genel olarak aşağıdaki şekilde yapılır;

DiziTipi DiziAdı[Büyüklük]

Örnek olarak 10 adet tam sayıyı tutacak bir A dizisi C/C++’ da aşağıdaki şekilde

bildirilebilir;

int A[10];

Bir dizi bellekte sabit büyüklükte bir yere yerleşir. Dizi tanımlandıktan sonra program

içerisinde dizinin bellekte kapladığı alan miktarında artma veya azalma yapmak

mümkün değildir.

Örmeğin, 100 elemanlı bir dizi tanımlanırsa, program içerisinde dizinin sadece 10

elemanı kullanılsa bile geri kalan 90 elemanı bellekte yer işgal etmeye devam eder. Bu

nedenle diziler tanımlanırken, dizilerde saklanılacak veri miktarı iyi analiz edilmelidir.

5.1. Dizilere yönelik algoritma örnekleri

Örnek 1:




n elemanlı bir sayı dizisinin girişini yapan bir C/C++ programı yazalım ve akış

diyagramını çizelim;

#include <stdio.h>

#include <conio.h>

int i,n;

int A[100];

void main(void)

{clrscr();

printf("dizi eleman sayisini giriniz: ");

scanf("%d",&n);

for(i=1;i<=n;i++)

{printf("dizi elemanı giriniz: ");

scanf("%d",&A[i]);

printf(" \n");

}

getch();

}

Örnek 2:

Girilen n elemanlı bir sayı dizisinin en büyük elemanını bulan bir C/C++ programı

yazalım ve akış diyagramını çizelim;

#include <stdio.h>

#include <conio.h>

int i,eb,n;

int A[100];

void main(void)

{clrscr();

printf("dizi eleman sayisini giriniz:

");

scanf("%d",&n);

for(i=0;i<n;i++)

{printf("dizi elemani giriniz: ");

scanf("%d",&A[i]);

printf(" \n");

}

eb=A[0];

for(i=1;i<n;i++)

{

if(eb<A[i]) eb=A[i];

}

printf("en buyuk sayi= %d\n",eb);

getch();

}




Örnek 3:

Klavyeden okunan bir dizi harfin alfabetik sıraya konulmasını sağlayan ve sonucu

ekrana yazan bir bir C/C++ programı ve akış diyagramını Örnek alg.4’ te

oluşturduğumuz algoritma mantığına göre oluşturalım.

Daha önce oluşturduğumuz algoritmadan bir fark olarak, C’ de döngü yapılarını

öğrendiğimiz için yapısal programlama kavramında istenmeyen “goto” deyimini

kullanmadan akış diyagramını ve programı oluşturalım.

Gireceğimiz harfleri söz dizisi tipine sahip olan bir dizi değişkeninde tutabiliriz. Fakat

burada söz dizisinin son elemanı olan “NULL” karakterini sıralamaya sokmadığımıza

ve ayrıca söz dizisinin ilk elemanı 0 nolu indis ile gösterildiğine dikkat edelim.

Bu durumda oluşacak akış diyagramı;




Akış diyagramına uygun C/C++ programını yazalım;

/* Karakter Siralama Programı*/

##include <stdio.h>

#include <stdlib.h>

#include <math.h>

int i,j,n,k;

char h[100];

char b;


{

printf("karakter dizisi eleman sayisini giriniz: ");

scanf("%d",&n);

printf("karakter dizisini bosluksuz giriniz: ");

scanf("%s",h);

printf(" \n");

k=n;

for(i=0;i<n;i++) /* dizinin ilk elemani 0 indisinde

dizinin son elemani NULL*/

{ k--;

for(j=0;j<k;j++)

{

printf("\n dizi -> %s ",h);

if(h[j+1]<h[j])

{

b=h[j];

h[j]=h[j+1];

h[j+1]=b;

}

printf(" i=%d, j=%d sirali dizi -> %s ",i,j,h);

}

}

printf("\n siralanmis dizi --> %s\n",h);

system("PAUSE");

return 0;

}




Örnek 4:

Girilen n elemanlı bir sayı dizisinin

en büyük ve en küçük elemanını ve

bunların yerlerini bulan bir C/C++

programı yazalım ve akış


#include <stdio.h>

#include <conio.h>

int i,eb,ek,yerb,yerk,n;

int A[100];

void main(void)

{clrscr();


scanf("%d",&n);

for(i=0;i<n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

eb=A[0]; ek=A[0];

yerb=0; yerk=0;

for(i=1;i<=n;i++)

{

if(eb<A[i])

{eb=A[i]; yerb=i+1;}

else if (ek>A[i])

{ek=A[i]; yerk=i+1;}

}

printf("en buyuk sayi= %d\n",eb);

printf("yer sirasi= %d\n",yerb);

printf("en kucuk sayi= %d\n",ek);

printf("yer sirasi= %d\n",yerk);




getch();

}

“if”- “else if” – “else” yapısı.

Yukarıdaki örnekte de görülebileceği gibi “if” yapısı ve “if” - “else if” - “else”

şeklinde de kullanılabilir.

if” - “else if” - “else” yapısının genel yazılım formatı;

if (koşul) then {işlemler

else if (koşul) then {işlemler}

…

else {işlemler}

Örnek 5:

Girilen n elemanlı bir sayı dizisinde hem 4’e hem 5’e bölünebilen sayıları bulan ve

başka bir diziye yükleyen bir C/C++ programı yazalım ve akış diyagramını çizelim.

Bir değer hem 4’ e hem de 5’ e bölünebiliyor ise en küçük ortak katları olan 20’ ye de

kalansız bölünebilmelidir. Yani bu sayının mod 20’ ye göre değeri 0 olmalıdır.

Programın akış diyagramı;




C/C++ Programı;

#include <stdio.h>

#include <conio.h>

int i,k,say,n;

int A[100], C[100];

void main(void)

{clrscr();


scanf("%d",&n);

for(i=0;i<n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

k=0; say=0;

for(i=0;i<n;i++)

{

if(A[i]%20==0)

{k++;

C[k]=A[i];

say++;

}

}

for(k=1;k<=say;k++)




{ printf("%d ",C[k]);

}

printf(" \n");

getch();

}

Örnek 6:

Girilen iki basamaklı tam sayılardan oluşan n elemanlı bir sayı dizisini (aşağıdaki

örnekte olduğu gibi) giriş sırasının tersine sıralayan ve her bir sayının onluk ve birlik

basamağındaki rakamların yerini değiştiren bir C/C++ programı yazalım ve akış

diyagramını çizelim.

Örnek dizi işlemi: [45 43 16 24 67 ] [76 42 61 34 54]

Yapılması gereken işlemde hem dizinin elemanlarının dizilişini tersine çevirme ve

hem de her bir elemanın

rakamlarının yerini değiştirme

işlemi var.

Dizilişin tersine döndürülmesi bir

“for” döngüsü içerisinde

yapılabilir. Bu sırada dizi

elemanlarının birlik ve onluk

basamaklarının değerleri

belirlenerek yerleri değiştirilir.

Dizi elemanlarının mod 10’ a göre

değerleri birlik basamağının

değerleridir.Aynı zamanda dizi

elemanlarını 10’ a bölüp sonucun

tam sayı kısmını alırsak bu da bize

elemanların onluk basamağı

değerlerini verir.

C/C++ programı ve akış diyagram;

#include <stdio.h>

#include <conio.h>

int i,o,b,n,nn;

int A[100], C[100];

void main(void)

{clrscr();


scanf("%d",&n);




for(i=0;i<n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

nn=n-1;

for(i=0;i<n;i++)

{

o=A[i]%10;

b= A[i]/10;

C[nn-i]=o*10+b;

}

for(i=0;i<n;i++)

{ printf("%d ",C[i]);

}

printf(" \n");

getch();

}

Örnek 7:

Küçükten büyüğe doğru sıralı bir şekilde girilen n elemanlı bir sayı dizisinde istenilen

bir sayıya ve yerine yarılama işlemiyle ulaşmayı sağlayan ve sonucu ekrana yazan bir

C/C++ programı ve akış diyagramını oluşturalım.

Yarılama işlemi: sıralı bir dizide istenilen bir sayıya ulaşmak için dizinin yarılanarak

ortasındaki elemanın sorgulanması şeklinde olur. Bu eleman sorgulanarak aranan

elemanın dizinin sağ yarısında mı yoksa sol yarısında mı olduğu araştırılır.

Belirlendikten sonra belirlenen yarıda da aynı yarılama işlemi devam ettirilir.

C/C++ programı ve akış diyagram;




#include <stdio.h>

#include <conio.h>

int i, n, sayi,ort,b,s,t;

int A[100];

void main(void)

{clrscr();


scanf("%d",&n);

printf(" \n");

for(i=1;i<n+1;i++)


scanf("%d",&A[i]);

printf(" \n");

}

b=1;s=n+1;t=1;

printf("aranacak sayiyi giriniz: ");

scanf("%d",&sayi);

printf(" \n");

while(t!=0)

{

ort=(b+s)/2;

if(A[ort]==sayi)

{printf("aranan sayi: %d\n",A[ort]);

printf("sirasi: %d\n",ort);

t=0;}

else

{if(s==b+1)

{printf("sayi yok !");

t=0;}

}

if(A[ort]<sayi) b=ort;

if(A[ort]>sayi) s=ort;

}

printf(" \n");

getch();

}

ÖDEV 3

Soru 3.1;




n elemanlı bir dizinin ikinci büyük elemanını bulan bir C/C++ programı yazınız ve akış


Soru 3.2;

n elemanlı bir dizide dışardan girilen bir sayının dizinin elemanlarından kaç tanesinden büyük

olduğunu bulan bir C/C++ programı yazınız ve akış diyagramını çiziniz.

Soru 3.3;

A ve B dizileri, n elemanlı ve elemanları 0 ve 1’ lerden oluşan iki dizidir. A ve B dizilerini

kullanarak bir C dizisi oluşturalım. C[i] değeri A[i] ve B[i]’ den en az birinin 1 olduğu yerde

1 oluyor. C dizisini veren bir C/C++ programı yazınız ve akış diyagramını çiziniz.

Soru 3.4;

Verilen bir dizinin her bir elemanı kendinden önce verilen elemanların toplamının üç

fazlasına eşittir. Birinci ve ikinci elemanı verilen bir dizinin ilk n elemanının değerini bulup

diziye yerleştiren bir C/C++ programı yazınız ve akış diyagramını çiziniz.

Soru 3.5;

1 ve 999 arasındaki tamsayılardan oluşan n elemanlı bir dizide dizi elemanlarının kaç

tanesinin bir basamaklı, kaç tanesinin iki basamaklı, kaç tanesinin üç basamaklı olduğunu

bulan bir C/C++ programı yazınız ve akış diyagramını çiziniz.

Soru 3.6;

n elemanlı bir sayı dizisinin negatif elemanlarını bir diziye, pozitif elemanlarını diğer bir

diziye yükleyen ve bunların ayrı ayrı ortalamasını bulan bir C/C++ programı yazınız ve akış


Soru 3.7;

A dizisi n elemanlı bir dizi ve B dizisi, A dizisinin elemanlarının 0-1 aralığındaki

ağırlıklarının bulunduğu n elemanlı diğer bir dizidir {A[i] elemanının ağırlığı, B[i] dir}. A

dizisinin elemanlarından ağırlığı dışarıdan girilen bir değerden büyük olanları yeni bir C

dizisine yükleyen ve bu elemanların sayısını bulan bir C/C++ programı yazınız ve akış


6. DİZİLERDE (VEKTÖRLERDE) ARAMA VE SIRALAMA ALGORİTMALARI.

Birçok uygulamada veri dizilerinin, belirli sırada olması istenir. Veriler sayısal ise

küçükten büyüğe veya büyükten küçüğe, alfa sayısal ise A’dan Z’ ye veya Z’ den A’




ya doğru sıralanabilir. Sıralı veriler üzerinde işlem/değerlendirme yapmak çok daha

hızlı ve kolaydır.

Günümüz bilgisayarlarında kullanılan algoritmaların önemli bir bölümünün sıralama

algoritmalarına gereksinim duyması sıralama algoritmalarının önemini ortaya

koymaktadır.

Günlük hayattan örnek olarak, hayatın her alanında kullanılan veritabanlarının

düzenlenmesi, güncellenmesi ve arama işlemlerinin çok hızlı yapılabilmesi için veri

alanlarının doğru bir biçimde sıralanması gereklidir.

Aynı sıralama probleminin çözümünde farklı araştırmacılar tarafından ortaya konmuş

çeşitli sıralama algoritmaları mevcuttur. Bunların her birinin diğerlerine kıyasla

kullanım alanına göre üstünlükleri ve eksik yönleri olmaktadır.

Çoklu veriler içerisinde, istenilen bilgiyi aramak programlarda en sık karşılaşılan

işlemlerden biridir. Herhangi bir veri yığınında, ilgili bilgiye ulaşmak için değişik

algoritmalar kullanılır.

Bu bölümde birkaç popüler sıralama ve arama algoritması anlatılacak ve dizilerde

kullanımı gösterilecektir.

Dizilerde sıralama ve arama algoritmaları aşağıda gösterimleri sayısal değerler

üzerinden yapılmasına rağmen, hem sayısal hem de alfa sayısal bilgiler için aynı

şekilde çalışır.

6.1. Dizilerde sıralama algoritmaları

6.1.1. Seçme sıralama (selection sort) algoritması

Seçme sıralama (selection sort) en basit sıralama algoritmalarındandır.

Dizideki ilk elemandan başlanır. Seçilen dizi elemanı ile bu elemandan sonra gelen

dizi elemanları sırası ile karşılaştırılır. Eğer küçüklük/büyüklük (sıralama isteğine

bağlı olarak) durumu var ise yerleri değiştirilir.

İkinci etapta dizinin ikinci elemanı ile bu elemandan sonra gelen dizi elemanları sırası

ile karşılaştırılır ve aynı şekilde eğer küçüklük/büyüklük durumu var ise yerleri

değiştirilir.

Bu karşılaştırma işlemi sondan bir önceki eleman ile son elemanın karşılaştırılmasına

kadar devam eder ve aynı şekilde eğer küçüklük/büyüklük durumu var ise yerleri

değiştirilir.

Küçükten büyüğe doğru sıralama yapan seçme sıralama (selection sort) algoritması

için akış diyagramını çizelim;




Bu sıralama algoritmasının C/C++ Programı;

/* Secme Siralama Algoritmasi*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int i,j,n,b,k;

int A[100];


{


scanf("%d",&n);

for(i=1;i<=n;i++)

{printf("A[%d]: ",i);

scanf("%d",&A[i]);

printf(" \n");

}

for(i=1;i<n;i++)

{

for(j=i+1;j<=n;j++)

{

printf(" dizi -> ");

for(k=1;k<=n;k++)

printf(" %d ",A[k]);




if(A[j]<A[i])

{b=A[i]; A[i]=A[j]; A[j]=b;}

printf("i=%d j=%d sirali ->",i,j);

for( k=1;k<=n;k++)


printf("\n");

}

}

printf("siralandi ->");

for(i=1;i<=n;i++)

{

printf("%d ",A[i]);

}

printf(" \n");

system("PAUSE");

return 0;

}

6.1.2. Kabarcık sıralama (bubble sort) algoritması

Bu algoritma başlangıçta yer değiştirme sıralaması olarak adlandırılmıştır.

Günümüzde kabarcık sıralaması olarak adlandırılmasının nedeni dizi içindeki büyük

elemanların algoritmanın her adımında dizi sonuna doğru lineer olarak ilerlemesidir.

Bu algoritmada baştan sona doğru yapılan taramalar ile arka arkaya gelen (ardışık)

elemanlar kıyaslanır. Eğer küçüklük/büyüklük durumu var ise yerleri değiştirilir.

Bu algoritma daha önce karakter sıralama için kullandığımız basit sıralama

algoritmasının (Örnek 3: Örnek alg.4) değişik bir versiyonudur.




Küçükten büyüğe doğru sıralama yapan kabarcık sıralama (bubble sort) algoritması

için akış diyagramını çizelim;


/* Kabarcik Siralama Algoritmasi*/

#include <stdio.h>

#include <stdlib.h>

int i,j,n,b,k;

int A[100];


{


scanf("%d",&n);

for(i=1;i<=n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

for(i=1;i<=n;i++)

{for(j=1;j<n;j++)

{

printf(" dizi ->",i,j);

for(k=1;k<=n;k++)





printf(" i= %d, j=%d çevrim ",i,j);

if(A[j+1]<A[j])

{b=A[j]; A[j]=A[j+1]; A[j+1]=b;}

printf("sirali ->");

for( k=1;k<=n;k++)


printf("\n");

}

}


for(i=1;i<=n;i++)

{

printf("%d ",A[i]);

}

printf(" \n");

system("PAUSE");

return 0;

}

6.1.3. Yerleştirmeli sıralama (insertion sort) algoritması

Bu yöntem sıralama problemlerine getirilen basit ve temel yaklaşımlardan biridir.

Algoritmada dizinin ikinci elemanından başlanarak elemanlar sırayla kontrol edilir.

Bu algoritmada her eleman, kendinden önceki alt dizideki elemanlar ile

karşılaştırılmakta ve daha küçük ise ilgili yerdeki araya yerleştirilmektedir. Bu şekilde

dizide geriye doğru ilerlenir. Bu işlem seçilen dizi elemanından küçük değer

kalmayıncaya kadar devam eder.




İlk dizi elemanı doğru yere yerleştirildikten sonra bir sonraki eleman seçilerek

yukarıdaki işlemler tekrarlanır. İşlem dizinin son elemanının seçimi ile tamamlanmış

olur.

Oyun kartlarının sıralanmasında ve yerleştirilmesinde de buna benzer bir yöntem

kullanılır. Önce desteden bir kart seçilip kartın geleceği doğru yer bulunur ve bu

yerden sonraki kartlar kaydırılarak ilgili kart araya yerine yerleştirilir. Tüm kartlar

sıralanana kadar bu işleme devam edilir.

Bu yaklaşımdan yola çıkarak dizi elemanının doğru yere yerleştirme işlemi, dizi

elemanının geçici değişkende tutularak kendisinden önce gelen, kendisinden büyük

elemanların sağa doğru kaydırılması ve boşalan yere bu elemanın yerleştirilmesi ile

gerçekleştirilir.

Küçükten büyüğe doğru sıralama yapan yerleştirmeli sıralama (insertion sort)

algoritması için akış diyagramını çizelim;





/* Yerlestirmeli Siralama Algoritmasi*/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

int i,j,n,b,k;

int A[100];


{


scanf("%d",&n);

for(i=1;i<=n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

for(i=2;i<=n;i++)

{

b=A[i]; j=i;

printf(" dizi -> ");

for(k=1;k<=n;k++)


while((b<A[j-1])&&(j>1))

{A[j]=A[j-1]; j--;}

A[j]=b;

printf("i=%d j=%d sirali ->",i,j);

for( k=1;k<=i;k++)


printf("\n");

}


for(i=1;i<=n;i++)

{

printf("%d ",A[i]);

}

printf(" \n");

system("PAUSE");

return 0;

}




6.1.5. Diğer sıralama algoritmaları

Bu ders kapsamında incelenecek olan ikili yerleştirmeli sıralama (binary insertion

sort), birleştirmeli sıralama (merge sort), hızlı sıralama (quick sort) ve kümelemeli

sıralama (heap sort) algoritmaları fonksiyon kavramı kullanmayı gerektirdiğinden,

fonksiyonlar ve özyineleme konusundan sonra ele alınacaktır.

6.2. Dizilerde arama algoritmaları

Çoklu veriler içerisinde istenilen veriyi aramak amacı ile kullanılan algoritmalar

arasında en yaygın olarak kullanılanları, sıralı arama ve ikili (binary) arama

algoritmalarıdır.

6.2.1. Sıralı arama algoritması

Yavaş olmasına rağmen basit olan bu algoritmada dizideki tüm elemanlar sıra ile

aranan değer ile karşılaştırılır. Bu işlem değer bulunana kadar devam eder.

Bu algoritma için kullanılacak olan C/C++ programı ve akış diyagramı;




#include <stdio.h>

#include <conio.h>

int i,ara,n;

int A[100];

void main(void)

{clrscr();


scanf("%d",&n);

for(i=0;i<n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

printf("aranan deger: ");

scanf("%d",&ara);

for(i=0;i<n;i++)

{if(ara==A[i])

{printf("deger: %d, sirasi: %d", A[i], i+1);

goto son;}

}

printf("aranan deger yok");

son:

getch();

}

6.2.2. İkili (binary) arama algoritması

İkili arama algoritmasının kullanılabilmesi için dizideki tüm elemanların sıralı olması

(küçükten büyüğe doğru olduğunu varsayalım) gerekir.

Karşılaştırma işlemine dizinin ortasında bulunan elemandan başlanır. Eğer aranan

eleman dizinin orta elemanından küçük ise dizinin ortadan sonraki üst kısmı atılır.

Eğer aranan eleman dizinin orta elemanından büyük ise dizinin ortadan önceki alt

kısmı atılır.

Bu şekilde dizi yarılanmış olur. Bir sonraki aşamada karşılaştırma dizinin kalan

parçasının orta elemanı ile yapılır.

Aranılan eleman bulununcaya kadar bu şekilde dizi yarılanarak karşılaştırma işlemi

devam eder.




Bu algoritma için kullanılacak olan C/C++ programı ve akış diyagramı;

#include <stdio.h>

#include <conio.h>

#include <conio.h>

int i,ara,n,k,ilk,ort,son;

int A[100];

void main(void)

{clrscr();


scanf("%d",&n);

for(i=1;i<=n;i++)


scanf("%d",&A[i]);

printf(" \n");

}

printf("aranan deger: ");

scanf("%d",&ara);

ilk=1; son=n; k=0;

while(ilk<=son && k!=1)

{ ort=(ilk+son)/2;

if(ara<A[ort]) son=ort-1;

else if (ara>A[ort]) ilk=ort+1;

else k=1;

}

if(k==1)

printf("deger: %d, sirasi: %d", A[ort], ort);

else

printf("aranan deger yok");

getch();

}

ÖDEV 4

1) n elemanlı bir dizindeki asal sayıları belirleyen ve bu asal sayıları küçükten büyüğe sıralı

olarak başka bir diziye yükleyen bir C/C++ programı yazınız ve akış diyagramını çiziniz.

2) n elemanlı iki A ve B dizisinin A[i]B[i] şeklindeki farklı dizi elemanlarını bulan bu

elemanların farklarını ve yerlerini C ve D adındaki iki diziye karşılıklı olarak saklayan bir

C/C++ programı yazınız ve akış diyagramını çiziniz.




7. ÇOK BOYUTLU DİZİLER (MATRİSLER).

Bazı durumlarda büyük miktarlarda veri dizileri kullanmak gerekebilir. Bu durumda

çok boyutlu dizi olarak adlandırabileceğimiz matrisler kullanılabilir. Çok matrisler

ayrıca matematiksel problem çözümlemelerinde ve görüntü saklamada ve işlemede

oldukça yoğun bir biçimde kullanılmaktadır.

Matrislerin her bir satırı bir dizi olarak düşünülebilir. Matrislerde de dizilerde olduğu

gibi indisler kullanılmaktadır. Çok boyutlu diziler, iki, üç veya daha fazla boyutlu

olabilirler.

Örneğin 10 satır ve 10 sütundan meydana gelen iki boyutlu bir A matrisi A[10][10]

şeklinde tanımlanır. İndis olarak i satırları ve j sütunları belirtmek üzere tanımlanır ise,

bu matrisin elemanları A[i][j] şeklinde ifade edilebilir. Bu örnek matris için i ve j

değerleri en fazla 10 olabilir.

Matrisler tanımlanırken genel olarak boyutları tanımlanır. NM’ lik bir matris, N satır

ve m sütundan oluşan ve NM elemana sahip bir matrisi ifade eder.

7.1. Matrislere yönelik algoritma örnekleri

Örnek 1:

n*m boyutlu bir sayı matrisinin girişini yapan bir C/C++ programı yazalım ve akış


A1- başla

A2- oku(n,m)

A3- i=0

A4- j=0

A5 oku(a[i][j])

A6- j=j+1

A8- eğer j<m ise git a5

A9-i=i+1

A10- eğer i<n ise git a4

A11-dur

#include <stdio.h>

#include <conio.h>

int i,j,n,m;

int A[100][100];

void main(void)

{clrscr();




printf("n degerini giriniz: ");

scanf("%d",&n);

printf("m degerini giriniz: ");

scanf("%d",&m);

for(i=1;i<=n;i++)

{for(j=1;j<=m;j++)

{ printf("A[%d][%d]: ",i,j);

scanf("%d",&A[i][j]);

}}

getch();

}

Örnek 2:

Girilen n*m boyutlu bir sayı matrisinde negatif ve pozitif elemanların sayısını ve

ortalamasını bulan yapan bir C/C++ programı yazalım ve akış diyagramını çizelim;

A1- başla

A2- oku(n,m)

A3 ng=0, poz=0, tn=0, tp=0

A4 i=0

A5 j=0

A6 oku(a[i][j])

A7 eğer a[i][j]<0 ise ng++ ve tn+=A[i][j]

A8- eğer a[i][j]>0 ise poz++ ve pn+=A[i][j]

A9 j=j+1

A10- eğer j<=m ise git a6

A11 i=i+1

A12 eğer i<=n ise git a5

A13 ort=tn/ng ve ortp=tp/poz

A14 yazdır(tn, tp, tnort, tport)

A15-dur

#include <stdio.h>

#include <conio.h>

int i,j,n,m,ng,poz;

float A[100][100];

float ortn,ortp,tn,tp;

void main(void)

{clrscr();


scanf("%d",&n);


scanf("%d",&m);

ng=0; poz=0; tn=0; tp=0;

for(i=1;i<=n;i++)

{for(j=1;j<=m;j++)

{printf("A[%d][%d]: ",i,j);

scanf("%f",&A[i][j]);




if(A[i][j]<0)

{ng++; tn+=A[i][j];}

else if(A[i][j]>0)

{poz++; tp+=A[i][j];}

}}

ortn=tn/ng;

ortp=tp/poz;

printf("negatif sayisi:%d\n",ng);

printf("negatif ortalama:%f\n",ortn);

printf("pozitif sayisi:%d\n",poz);

printf("pozitif ortalama:%f\n",ortp);

getch();

}

Örnek 3:

Girilen n*m boyutlu bir A matrisi

ile m*n boyutlu bir B matrisini

çarparak sonucu n*n boyutlu bir C

matrisine ve ekrana yazan bir

C/C++ programı yazalım ve akış


Matris çarpımını, oluşacak C

matrisinin her bir elemanı için

matematiksel olarak açağıdaki

şekilde ifade edebiliriz;

njibacm

k

kjikij ,...,2,1,*1

C matrisinin her bir elemanı için

bir “for” döngüsünde işlemler

yapılabilir. Oluşacak C matrisinin

n*n elemanı olacağı için tüm

elemanları hesaplamak için iki

“for” döngüsü gerekir. Sonuç

olarak matris çarpımı üç “for”

döngüsü içerisinde

gerçekleştirilebilir.

C/C++ programı ve akış

diyagramı;

#include <stdio.h>

#include <conio.h>




int i,j,k,n,m,t;

int A[99][99],B[99][99],C[99][99];

void main(void)

{clrscr();


scanf("%d",&n);


scanf("%d",&m);

for(i=1;i<=n;i++)

{for(j=1;j<=m;j++)

{ printf("A[%d][%d]: ",i,j);


}}

for(j=1;j<=m;j++)

{for(i=1;i<=n;i++)

{ printf("B[%d][%d]: ",j,i);

scanf("%d",&B[j][i]);

}}

for(i=1;i<=n;i++)

{for(j=1;j<=n;j++)

{t=0;

for(k=1;k<=m;k++)

{t+=A[i][k]*B[k][j];}

C[i][j]=t;

printf("%d ",C[i][j]);

}

printf("\n");

}

getch();

}

Örnek 4:

Girilen n*n boyutlu bir A matrisinin transpozesini bulan n*n boyutlu bir B matrisine

ve ekrana yazan bir C/C++ programı yazalım ve akış diyagramını çizelim.

Bir matrisin transpozesi, mevcut matrisin satırları ile sütunlarının yer değiştirlmesi ile

elde edilir. Matematiksel gösterimi ile yapılacak transpoze işlemi;

ABveyaAB T şeklinde ifade edilebilir. Oluşacak B matrisinin her bir

elemanı ise;




jiij ab şeklinde ifade edilebilir.

Matrisler n*n elemanı olacağı için tüm elemanları hesaplamak için iç içe iki “for”

döngüsü gerektirmektedir.

C/C++ programı ve akış diyagramı;

A1- Başla

A2- oku(n)

A3-i=0

A4- j=0

A5- oku(a[i][j])

A6 j=j+1

A7 eğer j<n ise git a5

A8 i=i+1

A9 eğer i<n ise git a4

A10-i=0

A11- j=0

A12-b[i][j]=a[j][i])

A13- yazdır(b[i][j])

A14- j=j+1

A15- eğer j<n ise git a12

A16- bekle

A17- i=i+1


A19 dur

#include <stdio.h>

#include <conio.h>

int i,j,n;

int A[99][99],B[99][99];

void main(void)

{clrscr();


scanf("%d",&n);

for(i=1;i<=n;i++)

{for(j=1;j<=n;j++)

{ printf("A[%d][%d]: ",i,j);


}}

for(i=1;i<=n;i++)

{for(j=1;j<=n;j++)

{B[i][j]=A[j][i];

printf("%d ",B[i][j]);

}

printf("\n");




}

getch();

}

Örnek 5:

Girilen 3*3 boyutlu bir A matrisinin determinantını bulan ve ekrana yazan bir C/C++

programı yazalım ve akış diyagramını çizelim.

3*3 boyutlu bir A matrisinin determinantı matematiksel olarak aşağıdaki şekilde ifade

edilebilir;

)(

)()det(

332112322311312213

322113312312332211

333231

232221

131211

aaaaaaaaa

aaaaaaaaa

aaa

aaa

aaa

A


A1- Başla

A2- oku(n)

A3-i=0

A4- j=0

A5- oku(a[i][j])

A6 j=j+1


A8 i=i+1


A10- solk=A[1][1]*A[2][2]*A[3][3]

+A[1][2]*A[2][3]*A[3][1]

+A[1][3]*A[2][1]*A[3][2];

A11- sagk=A[1][3]*A[2][2]*A[3][1]

+A[1][1]*A[2][3]*A[3][2]

+A[1][2]*A[2][1]*A[3][3];

A12- det=solk-sagk;

A13- Yazdır (det)

A14- dur

#include <stdio.h>

#include <conio.h>

int i,j,solk,sagk,det;

int A[99][99];




void main(void)

{clrscr();

for(i=1;i<=3;i++)

{for(j=1;j<=3;j++)

{ printf("A[%d][%d]: ",i,j);


}}

solk=A[1][1]*A[2][2]*A[3][3]

+A[1][2]*A[2][3]*A[3][1]

+A[1][3]*A[2][1]*A[3][2];

sagk=A[1][3]*A[2][2]*A[3][1]

+A[1][1]*A[2][3]*A[3][2]

+A[1][2]*A[2][1]*A[3][3];

det=solk-sagk;

printf("determinant = %d",det);

getch();

}

Örnek 6:

Girilen 2*2 boyutlu bir A matrisinin var ise tersini bulan ve 2*2 boyutlu bir B

matrisine ve ekrana yazan bir C/C++ programı yazalım ve akış diyagramını çizelim.

Bir A matrisinin tersi var ise det(A) 0 {determinatı sıfırdan farklı} olmalıdır. 2*2

boyutlu bir A matrisinin tersinin hesaplanması matematiksel olarak aşağıdaki şekilde

ifade edilebilir;

)()det()det(

11 bcadAburadaac

bd

AAB

dc

baA

şeklinde ifade edilebilir.


A1- Başla

A2- n=2

A3-i=0

A4- j=0

A5- oku(a[i][j])

A6 j=j+1


A8 i=i+1


A10-det=A[1][1]*A[2][2]-A[1][2]*A[2][1]




A11- eğer det=0 değil ise yadır(tersi yok) git 25

A12-B[1][1]=A[2][2];

A13- B[1][2]=-A[1][2];

A14-B[2][1]=-A[2][1]

a15-B[2][2]=A[1][1]

A16-i=0

A17- j=0

A18- B[i][j]=B[i][j]/det

A19- yazdır B[i][j]

A20- j=j+1

A21- eğer j<n ise git a18

A22- Enter a basana kadar bekle

A23- i=i+1


A25- dur

#include <stdio.h>

#include <conio.h>

void main(void)

{int i,j;

float A[99][99],B[99][99],det;

clrscr();

for(i=1;i<=2;i++)

{for(j=1;j<=2;j++)

{ printf("A[%d][%d]: ",i,j);

scanf("%f",&A[i][j]);

}}

det=A[1][1]*A[2][2]-

A[1][2]*A[2][1];

if(det!=0)

{B[1][1]=A[2][2];B[1][2]=-A[1][2];

B[2][1]=-A[2][1];B[2][2]=A[1][1];

for(i=1;i<=2;i++)

{for(j=1;j<=2;j++)

{B[i][j]=B[i][j]/det;

printf("%f ",B[i][j]);

}

printf("\n");

}

}

else printf("matrisin tersi yok");

getch();

}

Örnek 7:




Girilen n*m boyutlu bir A matrisinin sıfırdan farklı elemanlarını ve bunların yerlerini

yeni oluşturacağımız bir B matrisinde saklayalım (istendiğinde A matrisini bu yeni

matristen tekrar oluşturabilmeliyiz).

A matrisinin elemanlarının büyük çoğunlunun sıfır olduğu durumlarda, yapacağımız

bu işlem saklanacak verinin miktarını azaltıcı çok basit bir sıkıştırma algoritması

olarak düşünülebilir.

Örneğin; çok az hareketin olduğu bir görüntüde iki kare arasında değişmeyen

pikselleri 0 ile ifade ettiğimizi düşünürsek, 0 değerlerinin değişmeyi ifade eden diğer

değerlerden ne kadar çok olabileceğini tahmin edebiliriz.

Saklanacak 0’ dan farklı değerin, oluşturulacak B matrisinde 3. sütunda ve bu değerin

yer indislerinin de B matrisinde 1. ve 2. sütunlarda tutulacağını varsayalım. Bu

durumda B matrisi p*3 (p: A matrisindeki 0’ dan farklı değer sayısı) boyutlu olur.


A1- Başla

A2-Oku(n,m)

A3-i=0

A4- j=0

A5- oku(a[i][j])

A6 j=j+1

A7 eğer j<m ise git a5

A8 i=i+1


A10 p=0

A11- i=0

A12- j=0

A13- Eğer A[i][j]!=0 ise P=P+1,

B[p][1]=i, B[p][2]=j, B[p][3]=A[i][j]

A14 j=j+1


A16 i=i+1


A18- i=0

A19- j=0

A20- Yazdır(a[i][j])

A21 j=j+1


A23 i=i+1

A24 eğer i<n ise git a19 A25- dur

#include <stdio.h>




#include <conio.h>

void main(void)

{int i,j,n,m,p;

int A[100][10],B[100][3];

clrscr();

printf("n degeri: ");

scanf("%d",&n);

printf("m degeri: ");

scanf("%d",&m);

for(i=1;i<=n;i++)

{for(j=1;j<=m;j++)

{ printf("A[%d][%d]: ",i,j);


}}

p=0;

for(i=1;i<=n;i++)

{for(j=1;j<=m;j++)

{if(A[i][j]!=0)

{p++;

B[p][1]=i;

B[p][2]=j;

B[p][3]=A[i][j];}

}}

for(i=1;i<=p;i++)

{for(j=1;j<=3;j++)

{printf("%d ",B[i][j]);

}

printf("\n");

}

getch();

}

ÖDEV 5

Soru 5.1;

32*32 piksellik bir siyah beyaz resimde siyah piksellerin 1, beyaz piksellerin ise 0 ile ifade

edildiğini ve böyle bir resim bilgisinin 32*32 boyutlu bir A matrisinde tutulduğunu

varsayalım ve bu A matrisinin sıfırdan farklı elemanlarını ve bunların yerlerini yeni

oluşturacağınız bir B matrisinde saklayan yeni oluşturulacak B matrisini kullanarak resim

bilgisini tutan A matrisini tekrar oluşturan bir C/C++ programı yazınız ve akış diyagramını

çiziniz.

Soru 5.2;




Girilen n*m boyutlu iki A ve B matrisinin A[i][j]B[i][j] şeklindeki farklı elemanlarını bulan

ve bu elemanların farklarını ve yerlerini yeni oluşturacağınız bir C matrisinde saklayan ve A

matrisini ve yeni oluşturulacak C matrisini kullanarak B matrisini tekrar oluşturan bir C/C++

programı yazınız ve akış diyagramını çiziniz.

Soru 5.3;

Girilen n*n boyutlu bir A matrisini transpozesi ile çarparak (A*AT) sonucu bir n*n boyutlu

bir B matrisine saklayan bir C/C++ programı yazınız ve akış diyagramını çiziniz.

Soru 5.4;

Girilen 2*2 boyutlu bir A matrisini tersi ile çarparak (A*A-1

) sonucu bir 2*2 boyutlu bir I

matrisine saklayan bir C/C++ programı yazınız ve akış diyagramını çiziniz.

8. ALTPROGRAM KAVRAMI, FONKSİYON VE YORDAM ALTPROGRAMLARI.

Çoğu problemin çözümünde genellikle uzun programlara ihtiyaç duyulmaktadır.

Binlerce ifadeden oluşan bir programların yazılması ve anlaşılması oldukça zor bir

işlemdir. Bu sebeple problemin daha kolay çözülebilen alt parçalarına (modül)

ayrıştırılması işlemi yapısal programlamanın temel yaklaşımlarındandır.

Programlama dillerinde her bir modülün (alt parça) bağımsız olarak ele alınmasını

sağlayan ve alt program adı verilen birimler tanımlanır.

Altprogramlar büyük ve karmaşık problemin çözümünde yapısal programlamanın

etkin kullanımı için gerekli temel taşlarındandır.

Altprogramlar bir kere yazılır ve program içerisinde bir yada daha çok yerde

çağrılarak kullanılır.




Altprogram kullanmanın faydaları aşağıdaki gibi sıralanabilir;

o Belirli bir işi yapan program parçasının, birden çok yerde değişik veriler için

ayrı ayrı yazılmasını önlemek.

o Düşük düzeydeki ayrıntıları, program mantığının ana akışından uzaklaştırıp

ayrı modüllere yerleştirerek, programın tasarlanmasını kolaylaştırmak ve

okunulabilirliğini artırmak.

o Büyük bir programın, daha küçük ve yazılması daha kolay fonksiyonel

parçalara bölünmesini sağlamak.

o Program yazma işinin birden çok programcı tarafından paylaşılmasına olanak

sağlamak.

Programlama dillerinde genelde iki tür alt program kullanılır;

o Yordam (procedure, subrotine)

o Fonksiyon

Yordam ve fonksiyon özünde birbirine çok benzeyen altprogramlardır.

Programlama dillerinde genelde yordam fonksiyona göre daha genel amaçlıdır.

Fonksiyonlar ana programa bilgi geri gönderirken, yordamlardan bu beklenmez.

Ayrıca fonksiyonların argüman (işlenen değişken, parametre) kullanması gerekirken,

yordam argümansız olarak kullanılabilir.

Yordamı küçük bir program parçası şeklindeki bir altprograma, fonksiyonu da

hesaplamalarda matematiksel hesaplamalarda kullandığımız hesaplamalara benzer

işlem yapan bir altprograma benzetebiliriz.

8.1. C/C++’ da altprogram kullanımı

C/C++’ da fonksiyon kavramı yordam ve fonksiyonu ihtiva edebilecek şekilde geniş

tanımlanmıştır. Yani C/C++’ da hem yordam hem de fonksiyon aynı yapı kullanılarak

ifade edilir.

C/C++’ da altprogramlar fonksiyon ile ifade edilir. Fakat kullanımı hem yordamı hem

de fonksiyonu ifade edecek kadar geniştir.

C/C++’ da fonksiyonlar parametreli ve değer döndürerek fonksiyon şeklinde ve

parametreli veya parametresiz (void) olarak değer döndürmeden (void) yordam

şeklinde kullanılabilir.




C/C++’ da her fonksiyonun bir adı, tipi (döndürdüğü tip) ve argüman/argümanları

vardır. Fonksiyon adı C dilinin anahtar sözcüklerinden (if, do, for, vb.) olmamak

koşulu ile istenildiği gibi verilebilir.

Diğer yandan fonksiyon adının yapısal programlama mantığına uygun olarak yaptığı

işle uygun ve hatırlatıcı olması beklenir.

Fonksiyonun tipi kendisini çağırana göndereceği verinin tipini belirtir. Eğer bir

fonksiyon kendisini çağırana hiçbir veri göndermeyecek ise (yordam ise) tipi void

olmalıdır.

8.1.1. C/C++’ da fonksiyon tanımlanması ve bildirimi

C/C++’ da bir fonksiyonun genel yapısı aşağıda gösterildiği gibidir;

fonksiyon-tipi fonksiyon-adı (argüman listesi)

argümanların tip bildirimleri

{

yerel değişken bildirimleri

…

işlemler;

…

}

Bir C/C++ programında fonksiyonlar ana fonksiyon olan main() fonksiyonundan önce

veya sonra tanımlanabilir. Kullanılacak fonksiyon main() fonksiyonundan önce

tanımlanır ise bu durumda fonksiyonun ön bildirimine ihtiyaç yoktur.

Fakat özellikle büyük boyutlu programlar oluştururken programın okunulabilirliği

açısından main() fonksiyonundan önce ön bildirim yapıp fonksiyonu main()

fonksiyonundan sonra tanımlamak daha uygundur.

Argümanlar yerel değişkenlere benzerler ve sadece fonksiyon içerisinde tanınırlar.

Bildirimi yukarıda olduğu gibi fonksiyon adının hemen altında yada fonksiyon

parantezi içindeki argümanın önünde yapılabilir (formal bildirim).

Fonksiyon altprogramı kendisini çağırana veri gönderecek ise (fonksiyon ise),

“return” deyimi kullanarak sadece bir tane sonuç gönderebilir. Gönderilecek verinin

tipini fonksiyon-tipi belirler.

Daha öncede bahsedildiği gibi eğer bir fonksiyon kendisini çağırana hiçbir veri

göndermeyecek ise yordam şeklinde kullanılıyordur ve fonksiyon-tipi “void”

olmalıdır.

C/C++’ da bir fonksiyonun argümanı (formal parametresi) birden çok olabileceği gibi

hiç de olmayabilir. Hiç parametre yok ise derleyicinin isteğine göre hiç parametre

yazılmaz veya fonksiyon parantezi içine “void” yazılır.




Bir fonksiyonun her çağrılmasında standart kütüphanenin (stdlib.h) va_start(),

va_arg(), va_end() makro fonksiyonları kullanılarak farklı sayıda argüman parametre

olarak kullanılabilir. Bu ders kapsamında bu konu ele alınmayacaktır.

Bir C/C++ programında fonksiyon çağırma işini aşağıdaki şekilde olduğu gibi ifade

edebiliriz;

8.1.2. C/C++’ da fonksiyona parametre aktarımı

C/C++’ da bir fonksiyonuna parametre aktarımı (argüman kullanımı) iki şekilde

yapılabilir;

o Verinin değeri doğrudan aktarılabilir yani değer doğrudan parametre olarak

kullanılabilir (değer ile çağırma – calling by value).

o Verinin adresi (değişken) aktarılabilir yani değişken parametre olarak

kullanılabilir (adres ile çağırma – calling by reference).

Bunun ile birlikte fonksiyon argümanların bir kısmı değer bir kısmı da değişken

şeklinde olabilir.

Örnek 8.1;

C/C++’da fonksiyon tanımlanması, bildirimi ve parametre aktarımı ile ilgili basit bir

örnek program;

#include <stdio.h>

#include <conio.h>

int ekle(int, int); /* fonksiyon bildirimi – bazi derleyicilerde zorunlu */

/*ana fonksiyon*/

void main(void)

{ int x,y;




clrscr();

printf("yedi eklenecek sayiyi girin: ");

scanf("%d",&x);

y=ekle(x,7); /* fonksiyonun cagrilmasi */

printf("sonuc = %d",y);

getch();

}

/* fonksiyon tanimlama*/

int ekle(a,b)

int a,b;

{ int g;

g=a+b;

return g;

}

Örnek 8.2;

C/C++’da değişkenler arası verileri yer değiştiren bir fonksiyon (yordam olarak)

kullanılması ile ilgili basit bir örnek program;

#include <stdio.h>

#include <conio.h>

void degistir(void); /* fonksiyon bildirimi – bazi derleyicilerde zorunlu */

int x,y;

/*ana fonksiyon*/

void main(void)

{ clrscr();

printf("birinci sayiyi girin: ");

scanf("%d",&x);

printf("ikinci sayiyi girin: ");

scanf("%d",&y);

printf(" %d %d\n",x,y);

degistir(); /* fonksiyonun cagrilmasi */

printf(" %d %d ",x,y);

getch();

}


void degistir(void)

{ int g;

g=x;

x=y;

y=g;

}

Görüldüğü gibi kullanılan altprogram parametre aktarmayan bir yordam şeklinde

kullanıldığı için parametre aktarımı ve sonuçta değer döndürülmesi yapılmadı. Bu

sebep ile x, y global değişken olarak kullanıldı.




Değişkenlerin değer değiştirme işlemini daha etkin olarak yapabilmek için

oluşturacağımız yordam fonksiyonuna parametre aktarımı yapmak gerekir. Fakat

aktarım parametrelerine direkt olarak değer döndürülemeyeceği için, dolaylı olarak

değer döndürmek gerekir. Bu sebep ile işaretçi değişkenler kullanmak gerekir.

Yukarıdaki örneği parametre aktarımı yaparak aşağıdaki şekilde yeniden

düzenleyebiliriz;

#include <stdio.h>

#include <conio.h>

void degistir(int *, int *); /* fonksiyon bildirimi – bazi derleyicilerde zorunlu */

/*ana fonksiyon*/

void main(void)

{ int x,y;

clrscr();

printf("birinci sayiyi girin: ");

scanf("%d",&x);

printf("ikinci sayiyi girin: ");

scanf("%d",&y);

printf(" %d %d\n",x,y);

degistir(&x,&y); /* fonksiyonun cagrilmasi */

printf(" %d %d ",x,y);

getch();

}


void degistir(int *a, int *b)

{ int g;

g=*a; *a=*b; *b=g;

}

8.1.3. Altprogramın yan etkileri

Bir programın değişken değerlerini istenmeyen bir biçimde değiştirmesine yan etki

denilir. Bu durumda çoğu zaman istenmeyen sonuçlar doğurabilir.

Yan etkiden kaçınmak için çok önemli bir neden yoksa yordam yada fonksiyonda

global (genel) değişken kullanılmamalıdır. Mümkün olduğunca program modülleri

arasındaki iletişim parametre aktarımı ile yapılmalıdır.

Örnek 8.3;

Yan etkinin beklenmedik sonuçlara nasıl yol açacağını görmek için aşağıdaki C/C++

programını örnek olarak inceleyebiliriz;

#include <stdio.h>

#include <conio.h>




int f(int);

int x;

void main(void)

{ clrscr();

x=0;

printf("%d\n",f(0));



getch();

}

int f(int y)

{ int g;

g=x+y;

x++;

return g;

}

Yukarıdaki program çıktısında üç değerinde aynı olacağı sanılsa da bu bir yanılgıdır.

“f” fonksiyonu “x” global değişkeninin değerini değiştirdiği için aynı olması beklenen

çıktı değerleri her defasında değişir.

8.2. Özyineleme Kavramı

Birçok dilde olduğu gibi bir alt programı C/C++’ da da yalnızca başka bir altprogram/

program değil kendiside çağırabilir. Böyle bir çağırmaya özyineleme adı verilir ve bu

altprogramın özyineli olduğu söylenir.

Özyineleme, yinelemeye (döngü deyimleri kullanarak yapılan işlem tekrarları) bir

seçenek olarak düşünülebilir. Genellikle özyineli bir çözüm, bilgisayar zamanı ve

bellek kullanımı açısından yinelemeye göre daha az etkindir.

Fakat bazı durumlarda özyineleme, bir probleme doğal ve basit bir çözüm sağlar. Bu

nedenle özyinelemeli fonksiyon ve yordamlar diğer dilerde olduğu gibi C’ de de

önemli ve yararlı araçlardır.

Örnek 8.4;

Özyinelemeli bir fonksiyon kullanarak girilen bir pozitif değerin faktöriyelini

hesaplayan bir C/C++ programı yazalım.

Faktöriyelin matematiksel ifadesi aşağıdaki şekilde yazılabilir;

isennn

isenn

1)!1(

10,1!

C/C++ programı;




#include <stdio.h>

#include <conio.h>

long int fakt(int);

int x;

void main(void)

{ clrscr();

printf("sayiyi girin: ");

scanf("%d",&x);

printf("%d ! = %ld \n",x,fakt(x));

getch();

}

long int fakt(int a)

{ long int g;

if (a>1) g=a*fakt(a-1); /* n!=n*(n-1)! */

else g=1;

return g;

}

Örnek 8.5;

Bir x tamsayı değerinin 0 dan büyük pozitif n. üssünü (xn) hesaplamak amacı ile

özyinelemeli bir fonksiyon kullanan bir C/C++ programı yazalım.

Üs almanın matematiksel ifadesi aşağıdaki şekilde yazılabilir;

isenxx

isenxx

n

n

1

1,

)1(

C/C++ programı;

#include <stdio.h>

#include <conio.h>

long int us(int,int);

int x,n;

void main(void)

{ clrscr();

printf("sayiyi girin: ");

scanf("%d",&x);

printf("usu girin: ");

scanf("%d",&n);

printf("%d^%d = %ld \n",x,n,us(x,n));

getch();

}

long int us(int a,int b)

{ long int g;

if (b>1) g=a*us(a,b-1);

else g=x;

return g;




}

Örnek 8.6:

Verilen 8*3 boyutlu A ve B matrislerinin A[i][j]B[i][j] şeklindeki farklı elemanlarını

bulan ve bu elemanların farklarını ve yerlerini yeni oluşturacağınız bir p*3 boyutlu

yeni bir C matrisinde saklayan ve A matrisini ve yeni oluşturulacak C matrisini

kullanarak B matrisini tekrar oluşturan bir C/C++ programı ve akış diyagramını

altprogramlar kullanarak oluşturalım.

Saklanacak 0’ dan farklı fark değerlerini oluşturulacak C matrisinde 3. sütunda ve bu

değerin yer indislerinin de C matrisinde 1. ve 2. sütunlarda tutulacağını varsayalım. Bu

durumda C matrisi p*3 (p: A matrisindeki 0’ dan farklı değer sayısı) boyutlu olur.

B matrisini yeniden oluştururken öncelikle A matrisinin bütün elemanlarını B

matrisine atayabiliriz. Ardından farklı B matrisi elemanlarını hesaplamak için p

adımlık bir “for” döngüsü içerisinde ilgili elemanları bulmak için p satırlı C matrisini

kullanırız. Aynı döngü içerisinde farklı olması gereken bu B matrisi elemanlardan

ilgili C matrisi elemanını (3. sütundaki değer) çıkararak bu elemanın gerçek değerini

buluruz.

C programlamada fonksiyon kavramını incelediğimiz için bu problemin çözümünde

yapısal programlamanın çözümü daha kolay alt problemlere (modüllere) bölünme

ilkesinden faydalanabiliriz. Her bir modülü daha kolay çözülebilir bir altprogram

(yordam) olarak ele alabiliriz ;

Akış diyagramı;




C/C++ programı;

#include <stdio.h>

#include <conio.h>

void yenimat(int [8][3],int [8][3]);

void yeniden(int [][3],int [][3]);

void yaz(int [][3], int);

int p;

int A[8][3] = {{1,0,0},{0,1,1},{1,0,1},{1,1,0},{1,1,1},{1,0,0},{0,1,1},{0,1,0}};

int B[8][3] = {{1,0,1},{0,1,1},{1,0,1},{1,1,0},{1,1,1},{1,0,0},{0,1,1},{1,1,0}};

int C[24][3];

void main(void)




{ clrscr();

yaz(A,8);

yaz(B,8);

yenimat(A,B);

yaz(C,p);

yeniden(A,C);

yaz(B,8);

getch();

}

void yenimat(int mat1[8][3],int mat2[8][3])

{int i,j;

p=0;

for(i=0;i<8;i++)

{ for(j=0;j<3;j++)

{ if(mat1[i][j]!=mat2[i][j])

{ C[p][0]=i;

C[p][1]=j;

C[p][2]=mat1[i][j]-mat2[i][j];

p++;

}}}

}

void yeniden(int m1[][3],int m2[][3])

{int i,j;

for(i=0;i<8;i++)

{ for(j=0;j<3;j++)

{ B[i][j]=m1[i][j]; }}

for(i=0;i<p;i++)

{B[m2[i][0]][m2[i][1]]=m1[m2[i][0]][m2[i][1]]-m2[i][2]; }

}

void yaz(int matris[][3],int satir)

{int i, j;

for( i = 0; i < satir; i++ )

{ for( j = 0; j < 3; j++ )

{ printf( "%d ", matris[i][j] );}

printf( "\n" );}

printf( "\n" );

}

ÖDEV 6

Soru 6.1;

3333232131

2323222121

1313212111

bxaxaxa

bxaxaxa

bxaxaxa




Formundaki herhangi 3 bilinmeyenli denklemin denklem sistemi belirgin ise (tek çözümü var

ise) çözümünü hesaplayan bir C/C++ programı yazınız ve akış diyagramını çiziniz. Program

yapısal programlama mantığında altprogramlar kullanılarak oluşturulacak.

Not: Denklem sistemi matematiksel çözüm metodu araştırılacak (Bkz. Lineer Cebir Ders

Kitabı).

Soru 6.2;

2221

1211

aa

aa

Formundaki herhangi 2 *2 boyutlu bir matrisin özdeğerleri var ise hesaplayan bir C/C++

programı yazınız ve akış diyagramını çiziniz. Program yapısal programlama mantığında

altprogramlar kullanılarak oluşturulacak.

Not: Özdeğer hesaplama matematiksel çözüm metodu araştırılacak (Bkz. Lineer Cebir Ders

Kitabı).

8.3. Dizilerde Sıralama Algoritmaları için Altprogram Kullanımı

8.3.1. Hızlı sıralama (quick sort) algoritması

En çok tercih edilen sıralama algoritmalarından biridir. Bu algoritmadaki çözüm

yaklaşım “parçala ve çözümle” ilkesine göre çalışmaktadır.




Öncelikle sıralanacak diziden belirli bir kritere göre parçalayıcı bir eleman (örneğin

orta elemen) seçilir. Sıralanacak dizi bu elemandan küçük eşit ve bu elemandan büyük

olacak şekilde iki alt diziye bölünür.

Bu işlemin ardından yukarıdaki işlem her alt dizi için özyinelemeli olarak tekrarlanır.

C programlamada fonksiyon kavramını incelediğimiz için bu problemin çözümünde

yapısal programlamanın çözümü daha kolay alt problemlere (modüllere) bölünme

ilkesinden faydalanabiliriz. Her bir modülü daha kolay çözülebilir bir altprogram

(yordam) olarak ele alabiliriz.



Küçükten büyüğe sıralama yapan algoritma için akış diyagramı;




C/C++ programı;

#include <stdio.h>




#include <conio.h>

void oku (void);

void bol(int,int);

void hsirala(int,int);

void yaz (void);

int i,n,ort;

int A[100];

void main(void)

{ oku();

hsirala(1,n);

yaz();

}

void oku(void)

{ clrscr();


scanf("%d",&n);

for(i=1;i<=n;i++)

{printf("dizi elemanini girin: ");

scanf("%d",&A[i]); }

}

void bol(int x,int y)

{ int alt,ust,g,eksen;

eksen=A[(x+y)/2]; alt=x; ust=y;

do

{ while(A[alt]<eksen) alt++;

while(A[ust]>eksen) ust--;

if(alt<=ust)

{ if(alt!=ust) { g=A[alt]; A[alt]=A[ust]; A[ust]=g; }

alt++; ust--; }

} while(alt<=ust);

ort=ust;

}

void hsirala(int sol, int sag)

{if (sol<sag)

{ bol(sol,sag);

if(sol<ort) hsirala(sol, ort);

if(sag>ort+1) hsirala(ort+1,sag);

}

}

void yaz(void)

{clrscr();

for(i=1;i<=n;i++) printf("%d ",A[i]);

printf(" \n");

getch();

}

8.3.2. Birleştirmeli sıralama (merge sort) algoritması




Bu sıralama algoritması “parçala

çözümle ve birleştir” ilkesini

kullanır. Bu algoritmada sıralanacak

olan dizi ortadan iki alt diziye

bölünür.

Bu algoritmada öncelikle sıralanacak

dizi birer elemandan oluşan alt

diziler elde edilene kadar

özyinelemeli olarak ikiye bölünür.

Ardından alt diziler sıralı olarak

birleştirilerek sıralı dizi elde edilir;

Bu problemin çözümünde yapısal

programlamanın çözümü daha kolay

alt problemlere (modüllere) bölünme

ilkesinden faydalanabiliriz.

Her bir modülü daha kolay çözülebilir bir altprogram (yordam) olarak ele alabiliriz.







C/C++ programı;




#include <stdio.h>

#include <conio.h>

void oku (void);

void bol(int,int);

void birles(int,int,int);

void yaz (void);

int n;

int A[100];

void main(void)

{ oku();

bol(1,n);

yaz(); }

void oku(void)

{ int i;

clrscr();


scanf("%d",&n);

for(i=1;i<=n;i++)


scanf("%d",&A[i]); }

}

void bol(int alt,int ust)

{ int ort,alts,usts;

if(alt<ust)

{ alts=alt; usts=ust;

ort=(alts+usts)/2;

bol(alts,ort); bol(ort+1,usts); birles(alts,ort,usts); }

}

void birles(int alts, int ort, int usts)

{ int i,ass,usb,g;

ass=ort; usb=ort+1;

while ((alts<=ass)&&(usb<=usts))

{ if (A[alts]<A[usb])

alts++;

else

{ g=A[usb];

for (i=usb-1;i>=alts;i--) A[i+1]=A[i];

A[alts]=g;

alts++;ass++;usb++;

} }

}

void yaz(void)

{int i;

clrscr();

for(i=1;i<=n;i++) printf("%d ",A[i]);

printf(" \n");

getch(); }

8.3.3. Kümeleme/yığın sıralama (heap sort) algoritması.




Kümeleme(heap) veri yapısı ikili

ağaçların özel bir halidir. Bu yapıda

her ebeveyn düğümün çocuk

düğümlerin kendisinden küçük yada

kendisine eşit olması kuralı esas alınır

(bunun terside kullanılabilir).

Oluşan ağaç (heap) yapısının dizilerde gösterimi ise aşağıdaki şekilde olur;

o Ağacın en büyük değerli elemanı (root

node: kök düğüm) her zaman dizinin

ilk elemanıdır.

o Dizi üzerinde her i. ebeveyn düğümün çocuk düğümleri 2i. ve (2i+1). konumda

olacaktır.

o Verilen bir diziden kümeleme (heap) oluşturmak için her i. ebeveyn düğümle

2i. ve (2i+1). çocuk düğümleri karşılaştırıp ebeveyn düğümden büyük olan

çocuk düğümleri ebeveyn düğümle yer değiştirmemiz gerekecektir.

o Bu işlemi dizinin orta elemanına kadar yapmamız yeterlidir. Yarıdan sonraki

diğer elemanlar ebeveyn olmayan çocuk elemanlar olduğundan bunlar için

işlem yapmaya gerek yoktur.

Elde edilen kümelenmiş diziyi sıralamak için ise, kümenin ilk elemanın dizinin en

büyük elemanı olduğunu bildiğimizden dizinin ilk elemanı ile son elemanının yerini

değiştirerek en büyük elemanı sona atmış oluruz.

Sonuncu elemanı içermeyen yeni dizi tekrar kümeleme işlemine tabi tutulur. Bu yeni

dizide de ilk eleman ile son elemanın yeri değiştirilir.

Bu yineleme işlemi dizinin boyu bir oluncaya kadar devam eder.

Bu problemin çözümünde de özyinelemeli modüler yordamlar kullanılacaktır.





C/C++ programı;




#include <stdio.h>

#include <conio.h>

void oku (void);

void kumesirala(void);

void kumele(int,int);

void yaz (void);

int n;

int A[100];

void main(void)

{ oku();

kumesirala();

yaz(); }

void oku(void)

{ int i;

clrscr();


scanf("%d",&n);

for(i=0;i<n;i++)


scanf("%d",&A[i]); } }

void kumesirala(void)

{int i,nd,g;

nd=n;

for (i=nd/2;i>0;i--) kumele(i,nd);

do

{ g=A[0]; A[0]=A[nd-1]; A[nd-1]=g;

nd--;

kumele(1,nd);

}while(nd>1);

}

void kumele(int k,int nx)

{ int j,g;

g=A[k-1];

while (k<=nx/2)

{ j=2*k;

if((j<nx)&&(A[j-1]<A[j])) j++;

if(g>=A[j-1]) break;

else { A[k-1]=A[j-1]; k=j;}

}

A[k-1]=g;

}

void yaz(void)

{int i;

clrscr();

for(i=0;i<n;i++) printf("%d ",A[i]);

printf(" \n");

getch();}

ÖDEV 7 – Genel Konular




Soru 7.1;

İkili yerleştirmeli sıralama (binary insertion sort) algoritmasını araştırınız. Bu

algoritmanın büyükten küçüğe sıralama yapan akış diyagramını çizin ve C/C++

programını yazınız.

Algoritmanın işleyişini inceleyiniz ve işleyiş metodunu kısaca izah edinir.

Soru 7.2;

n4 boyutlu bir A matrisin satırlarını, dördüncü sütundaki değerler küçükten büyüğe

sıralayacak şekilde sıralayan bir akış diyagramını çizin ve C/C++ programını yazınız.

Örnek sıralama;

Sıralamadan önce: Sıralamadan sonra:

7346

6735

5942

4524

3478

5942

3478

7346

4524

6735

Soru 7.3;

İlk satırı klavyeden rasgele girilen 4x4 boyutlu bir Latin karesini oluşturan ve ekrana

yazan bir C/C++ programı yazınız ve akış diyagramını çiziniz.

44 boyutlu bir Latin karesi içerisinde 1 den 4’ e kadar olan tamsayılar 4 kez kullanılır

ve bir satır veya bir sütun da aynı sayıdan sadece 1 tane bulunur.

44 boyutlu örnek Latin kareleri;

2341

3124

1432

4213

1432

2143

3214

4321

8.4. Genel Algoritma Örnekleri:




Örnek 8.7:

Girilen bir yılın verilen bir gününün hangi ayda olduğunu hesaplayan bir C/C++

programı yazalım ve akış diyagramını çizelim.

Örneğin: 2004 yılın 42. günü şubat ayındadır.

Bu problemi çözerken yılın aylarını ifade eden 12 elemana sahip bir “söz

dizisi/string” dizisi ve ayrıca ayların gün sayılarını da sırası ile tutan 12 elemana sahip

bir tamsayı dizisi kullanacağız

Bir “söz dizisi/string” dizisi, ya elamanları karakter işaretçi olacak biçimde yada

boyutu bir artırılarak bildirilir;

char *aylar[] = {"OCAK", "SUBAT", "MART", "NISAN", "MAYIS", "HAZIRAN",

"TEMMUZ", "AGUSTOS", "EYLUL", "EKIM", "KASIM", "ARALIK"};

char aylar[][7] = {"OCAK", "SUBAT", "MART", "NISAN", "MAYIS", "HAZIRAN",

"TEMMUZ", "AGUSTOS", "EYLUL", "EKIM", "KASIM", "ARALIK"};

Programı oluştururken dikkat etmemiz gereken bir husus da 4’ e tam bölünen yılarda

şubat ayının 29 gün olmasıdır.


C/C++ programı;




#include <stdio.h>

#include <conio.h>

char *aylar[] = {"OCAK", "SUBAT", "MART",

"NISAN", "MAYIS", "HAZIRAN",

"TEMMUZ", "AGUSTOS", "EYLUL",

"EKIM", "KASIM", "ARALIK"};

int ngun[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

void main(void)

{ int yil, t, gun, i;

clrscr();

printf("YIL girin: ");

scanf("%d",&yil);

printf("kacinci gun: ");

scanf("%d",&gun);

t=0;

if(yil%4==0) ngun[1]=29;

for(i=0;i<12;i++)

{t=t+ngun[i];

if(t>=gun) break;

}

printf("%d. gun %s ayindadir", gun, aylar[i]);

getch();

}

Örnek 8.8:

İlk satırı rasgele dizilmiş Latin kareleri oluşturan bir C/C++ programı yazalım ve akış


nn boyutlu bir Latin karesi içerisinde 1 den n’ e kadar olan tamsayılar n kez kullanılır

ve bir satır veya bir sütun da aynı sayıdan sadece 1 tane bulunur.

33 ve 44 boyutlu örnek Latin kareleri;

321

132

213

2341

3124

1432

4213

Problemi altprogram olarak ayrı ayrı ele alabileceğimiz üç modüle ayırabiliriz:

o Rasgele ilk satırın oluşturulması,

o Latin karesinin oluşturulması,

o Latin karesinin yazılması.




Rasgele ilk satırın oluşturulması: nn boyutlu Latin karesinin ilk satırını, elemanlarını

rasgele belirleyeceğimiz n elemanlı bir A dizisinde tutalım. C/C++’ nın “randomize()”

ve “random()” hazır fonksiyonlarını kullanarak rasgele sayılar üretebiliriz ve bu

sayıların eşit olmamasını iki “for” döngüsü içinde kontrol edebiliriz. Bir do-while

döngüsüde A’ nın bütün elemanları farklı oluncaya kadar rasgele sayı üretmek amacı

ile kullanılabilir.

Latin karesinin oluşturulması: Elde ettiğimiz ilk satır aslında sayıların dönerli

permütasyonudur (Latin karesi içindeki her satırda değişik olacak yerlerini verir).

Örnek olarak ilk satır [4 1 3 2] olsun. İlk satır bize sayıların Latin karesindeki dönerli

yerleşimlerini de bize verir . Örneğin 4 sayısının yerleşimi [1 3 2 4] şeklindedir yani

ilk satırda 1. sırada ikinci satırda 3. sırada üçüncü satırda 2. satırda ve dördüncü satırda

4. sıradadır. [1 3 2 4] yerleşimini [4 1 3 2] şeklindeki ilk satırımızı sola döndürerek

kaydırma suretinde elde edebiliriz. Yerleşimdeki ilk eleman işleme tutulacak elemanı

da gösterir. [1 3 2 4] yerleşimini bir kere daha sola döndürerek kaydırırsak [3 2 4 1]

yerleşimini elde ederiz. Yerleşime tabi tutulacak eleman ilk satırın 3. sırasındaki 3 tür.

Yeni oluşan [3 2 4 1] yerleşimini bir kere daha sola döndürerek kaydırırsak [2 4 1 3]

yerleşimini elde ederiz. Bu kez sıralama ilk satırın 2. elemanı olan 1 içindir. [2 4 1 3]

yerleşimini bir kere sola döndürerek kaydırırsak [4 1 3 2] dizisini elde ederiz. Sıralama

ya tabi tutulacak eleman ilk satırın 4. elemanı olan 2 dir.


C/C++ programı;




#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <time.h>

void ilksatir (void);

void latinkare(void);

void yaz (void);

int n;

int A[10], L[10][10];

void main(void)

{ilksatir();

latinkare();

yaz();

}

void ilksatir(void)

{ int i,j,t;

clrscr();

printf("latin matrisi icin boyutu icin 2-9 arasi bir deger girin: ");

scanf("%d",&n);

randomize();

do{

for(i=1;i<=n;i++) A[i]=random(n)+1;

t=0;

for(i=1;i<=n;i++)

{ for(j=1;j<=n;j++)

{ if((i!=j)&&(A[i]==A[j])) t++; }}

}while(t!=0);

}

void latinkare(void)

{int g, i, j, k, ns, p, sayi, ysut, YER[10];

ns=n-1;

for (i=1;i<=n;i++) YER[i]=A[i];

for (i=1;i<=n;i++)

{g=YER[1];

for (j=1;j<=ns;j++) YER[j]=YER[j+1];

YER[n]=g;

p=YER[1];

sayi=A[p];

for (k=1;k<=n;k++)

{ ysut=YER[k];

L[k][ysut]=sayi;}

}}

void yaz(void)

{int i,j;

clrscr();

for(i=1;i<=n;i++)

{ for(j=1;j<=n;j++) printf("%d ",L[i][j]);

printf(" \n"); }

getch(); }




Örnek 8.9:

Bir fonksiyonun belirli bir aralıkta hesabı analitik yollar ile zor olabilir veya mümkün

olmayabilir. Bu gibi durumlarda sayısal integrasyon yöntemlerine başvurulur.

Simpson Kuralı bu yöntemlerden biridir.

Simpson Kuralı aşağıdaki şekilde ifade edilebilir;

y=f(x) şeklinde bir fonksiyonun x=a ile x=b arasında integralinin hesabı, (a,b)

aralığında fonksiyon eğrisi ile x ekseni arasında kalan alana eşittir. Simpson Kuralına

göre (a,b) aralığını yukarıdaki şekilde olduğu gibi n parçaya bölerek aşağıdaki integral

hesabını yazabiliriz;

nnn ffffffffh

Integral 1243210 42...24243

Örnek integrasyonumuz dxxexF x 54 )5.0()( şeklinde olsun.

İntegrasyon için Simpson kuralını uygulayan programın akış diyagramı;




C/C++ programı;

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <math.h>

double integral (float, float, int);

double fonk(float);

int n;

void main(void)

{ float bas,son; int bs; double sonuc;

clrscr();

printf("integral aralik baslangici: ");

scanf("%f",&bas);

printf("integral aralik sonu: ");

scanf("%f",&son);

printf("aralik bolum sayisi (cift): ");

scanf("%d",&bs);

sonuc=integral(bas,son,bs);

printf("integral degeri : %f ", sonuc);

getch();

}

double integral(float a, float b, int n)

{double F[100], toplam, integ; float h,x; int i;

h=(b-a)/n;

x=a;

for(i=0;i<=n;i++)

{F[i]=fonk(x); x=x+h;}

toplam=0;

for(i=1;i<n;i+=2) toplam=toplam+4*F[i]+2*F[i+1];

integ=(h/3)*(toplam+F[0]-F[n]);

return integ;

}

double fonk(float z)

{float f;

f=exp(-4* z)*pow((0.5+z),5); /*hazir C matematik fonksiyonlari */

return f;

}

Niçin Diskleri Kullanıyoruz(Why we are using a disk)?

Bilgisayarla çalışan insanlar olarak verileri dosyalarda saklamanın önemini çok iyi

biliyoruz. Bilgisayarın ana hafızası(RAM) bilgisayardaki sabit disklerden çok çok

azdır. Yani Sabit diskler(harddisk) RAM’den daha fazla bilgi saklar. Diskler

içerisindeki bilgileri enerji kesildiğinde dahi tutar. Kullanıcı istediği zaman disk

üzerindeki verileri çağırarak değiştirir data.

Disk dosyalarına erişim tipleri(Type of disk file access)




Programlar dosyalara iki farklı şekilde ulaşırlar; sıralı ve rasgele. Yazdığınız

program sizin ulaşım seçiminize göre değişiklik gösterecektir. Dosyaya erişim

modunuz, sizin dosyadan veriyi nasıl okuyacağınızı, dosyaya veriyi nasıl

yazacağınızı, dosyadaki verileri nasıl değiştireceğinizi veriyi dosyadan nasıl

sileceğinizi ve benzeri durumları belirlemenizi sağlar. Bazı dosyalara iki şekilde de

ulaşılabilir.

fopen fonksiyonu(The fopen() Function)

fopen() fonksiyonu iki fonksiyon icra eder: birincisi kullanmak üzere bir dosya açar,

ikincisi ise bir dosya işaretcisi döndürür. Fopen() fonksiyonunun genel kullanımı

FILE *fp;

fp=fopen(fdosyaadı,mode);

Burada mode string bir ifadedir ve aşağıdakilerden biri olabilir.

r okuma

w yazma, veya

a ilave etme

Dosya ismi karakter dizini olmalı ve kullanılan işletim sistemine uygun bir

karakterlerin kullanılmasıdır.

Fp dosya tipi değişkenidir ve dosya işaretcisidir. FILE stio.h kütüp hanesinde

tanımlı özel bir veri tipidir. Bütün dosya işaretcileri FILE tipi olarak tanımlanmak

zorundadır.

Eğer yazma modunda “test” isimli bir dosya açmak istiyorsak aşağıdaki ifadeyi

kullanabiliriz

fp=fopen(“test”,”w”);

fopen fonksiyonu(The fopen() Function)

Bununla birlikte genellikle aşağıdaki ifade şekli ile kullanılacak veya

kullanılmaktadır:

if((fp=fopen(“test”,”w”))==NULL)

{

puts(“Dosya açılamıyor \n”);

exit();

}

Bu metod dosyanın diskte oluşturulamaması durumlarında verilen dosya

oluşturulamama hatalarında programın çalışmayı durdurmadan kullanıcının

duruma müdahalesi için kullanılır. Genellikle bu hata diskin dolu olması veya

yazmaya korumalı olması durumlarında oluşur.

fopen fonksiyonu ile bir dosya write modun da açıldığında, dosya yeniden

oluşturulur. Eğer daha önceden oluşturulmak istenen dosya oluşturulmuş ve bilgi

girilmişse bu bilgiler kaybedilir. Dosyaya sadece ilave kayıt eklenmek isteniyorsa

dosya append yani a modun da açılmalıdır.

fclose() fonksiyonu (The fclose() Function)

Fclose() fonksiyonu fopen() fonksiyonu ile açılan dosyaları kapatmak için kullanılır.

Program sonlandırılmadan önce tüm dosyalar kapatılmış olmalıdır.

fclose() fonkisyonun genel kulanım şekli

fclose(fp);




Burada fp fopen() fonksiyonu tarafından döndürülen dosya işaretçisidir.

fprintf() ve fscanf() fonksiyonları

Temel I/O fonksiyonları gets() ve putc() ye ilave olarak çoğu c kütüphaneleri fprint()

ve fscanf() fonksiyonlarına sahiptir. Fopen ile açılan dosyaya formatlı veri yazmak

ve okumak için kullanılırlar fopen() fonksiyonunun genel kullanımı

fprintf(fp,kontrol karakter dizini, argüman listesi);

Ve scanf() fonksiyonunun genel kullanımı

fscanf(fp, kontrol karakter dizini, argüman listes);

fprintf() ve fscanf() fonksiyonları

fp, fopen() fonksiyonu ile dönen dosya işaretçisidir. fprint() ve fscanf() fonksiyonları

fp işaretçisi ile tanımlanan dosyaya yönetmenin haricinde printf() ve scanf()

fonksiyonu gibi çalışır.

#include<stdio.h>

main()

{

FILE *fp;

char s[80];

int t;

if((fp=fopen(“test”,”w”))==NULL)

{

puts(“dosya açılamıyor\n”);

exit(0);

}

scanf(“%s %d”,s,&t); // veri oku

fprintf(fp,”%s %d”,s,t); // dosyaya yaz

fclose(fp);

if((fp=fopen(“test”,”r”))==NULL)

{

puts(“dosya açılamıyor \n”);

exit(0);

}

fscanf(fp,“%s %d”,s,&t); // dosyadan oku

printf(”%s %d”,s,t); // ekrana yazzdır

fclose(fp);

}

Programda aşağıdakine benzer bir menü oluşturulabilir ve program bu menü

araçılığı ile kontrol edilebilir.

#include <stdio.h>

#include <stdlib.h>

char sec;


{

do{

printf("\n personel takip programı ");




printf("\n 1- Kayıt ekle ");

printf("\n 2- Kayıt Güncelleştirme ");

printf("\n 3- Kayıt silme ");

printf("\n 4- kayıt arama ");

printf("\n 5- Programdan Çıkış ");

printf("\n SeÇiMiNiZ ? ");

do{sec=getch();}while((sec<'0')||(sec>'5'));

switch (sec)

{

case '1': printf("\n Kayıt Ekleme ");break;

case '2': printf("\n Kayıt Güncelleştirme ");break;

case '3': printf("\n Kayıt Silme ");break;

case '4': printf("\n Kayıt Arama ");break;

case '5': printf("\n Programdan Çıkış "); return 0;break;

default:printf(" yeniden deneyin ");

}

}while(sec='5');

system("PAUSE");

return 0;

}

enter()

{

if((filemain= fopen(“personal.dat”,”a”))==NULL)

{printf(“Dosya açılamadı \n”);

exit(0); }

printf( “\n Kişi adı :”);scanf(“%s “,person_name);

printf( “\n Kişi soyadı :”);scanf(“%s “,person_surname);

printf( “\n Kişi yaşı :”);scanf(“%d “,&person_age);

printf( “\n Kişi maaşı :”);scanf(“%d “,&person_salary);

fprintf(fileman, “%s %s %d %f \n“, person_name,person_surname, person_age,

person_salary);

fclose(filemain);

return;}

enter()

{

if((filemain= fopen(“personal.dat”,”a”))==NULL)


exit(0); }




printf( “\n Kişi maaş :”);scanf(“%d “,&person_salary);


person_salary);

fclose(filemain);




return;}

edit()

{

printf( “\n Dosyadan kayıt düzeltme ”);

printf( “\n ---------------------------------------------”);

printf( “\n person_surname :”);scanf(“%s “,tmp_surname);

if((filemain= fopen(“personal.dat”,”r”))==NULL)


exit(0); }

if((filetemp= fopen(“personal.tmp”,”w”))==NULL)

{printf(“ Dosya açılamadı \n”);

exit(0); }

Do

{

fscanf(fileman, “%s %s %d %f \n“, person_name,person_surname,&person_age,

&person_salary);

İf(tmp_surname==person_surname)

{

printf( “\n Kişi adı :”,person_name);

printf( “\n Kişi soyadı :”,person_surname);

printf( “\n Kişi yaşı :”,person_age);

printf( “\n Kişi maaşı :”,person_salary);

pintf(“ \n -------------------------------------------------------”);

printf(“ \n ------ Kaydı düzeltme ------------------------”);




printf( “\n Kişi maaşı :”);scanf(“%d “,&person_salary);

printf( “Yapılan değişiklikleri kaydetmek istiyormusunuz (y) yes (n)

no”);scanf(“%s”,&pass);

if( pass!=‘y’ || pass!=‘Y’)


person_salary);

}

}while(!feof(filemain));

fclose(filemain);

fclose(filetmp);

Remove(“personal.dat”);

Rename(“pesonal.tmp”, “personal.dat”);

return;

}

deletet()

{

printf( “\n Uyarı dosyadan kayıt siliyorsunuz”);

printf( “\n ---------------------------------------------”);

printf( “\n Kişi adı :”);scanf(“%s “,tmp_surname);


{printf(“dosya açılamadı \n”);




exit(0); }

if((filetemp= fopen(“personal.tmp”,”w”))==NULL)


exit(0); }

Do

{


&person_salary);


{

printf( “\n person_name :”,person_name);

printf( “\n person_surname :”,person_surname);

printf( “\n person_age :”,person_age);

printf( “\n person_salary :”,person_salary);

printf( “ Bu kaydı silmek istiyormusunuz (y) yes (n) no”);scanf(“%s”,&pass);

if( pass!=‘n’ || pass!=‘’)

fprintf(filetmp, “%s %s %d %f \n“, person_name,person_surname, person_age,

person_salary);

}

else

fprintf(filetmp, “%s %s %d %f \n“, person_name,person_surname, person_age,

person_salary);


fclose(filemain);

fclose(filetmp);

Remove(“personal.dat”);

Rename(“pesonal.tmp”, “personal.dat”);

return;

}

find()

{

printf( “\n Dosyadan kayıt bulma ”);

printf( “\n ---------------------------------------------”);

printf( “\n person_surname :”);scanf(“%s “,tmp_surname);



exit(0); }

Do{


&person_salary);


{

printf( “\n person_name :”,person_name);

printf( “\n person_surname :”,person_surname);

printf( “\n person_age :”,person_age);

printf( “\n person_salary :”,person_salary);

printf( “devam etmek istiyormusun… (y) yes (n) no”);scanf(“%s”,&pass);




if( pass!=‘n’ || pass!=‘N’)

{

fclose(filemain);

return;

}

}


fclose(filemain);

return;

}

Soru 1)a) Bir firmada çalışan n tane eleman olsun. Bu elemanların, adı,soyadı, maaş ve yaş

bilgilerini klavyeden okuyan daha sonrada çalışanların maaş ve yaşlarına göre aşağıdaki

verilen koşullara kişi adetlerini, maaş ve yaş ortalamalarını bulmak için akış diyagramını

çiziniz? 20≤yas<25 ve maaş<1500, 1500≤maaş<2000 ve 2000≤maaş

25≤yas<35 ve maaş<1500, 1500≤maaş<2000 ve 2000≤maaş

35≤yas ve maaş<1500, 1500≤maaş<2000 ve 2000≤maaş

b) sözde kodunu yazınız?

soru 2)

Bir iki boyutlu nxm elemanlı B dizisi olsun A dizisi ise

aşağıda verilen formül ile hesaplanmaktadır.

a) B dizisinin elemanlarını klavyeden okuyan

b) B dizisini ekrana yazdıran

c) A dizisini hesaplayan

d) A dizisini ekrana yazdıran

algoritmanın akış diyagramını ve sözde kodunu veriniz?

Algoritmalarbook

Documents

Transcript of Algoritmalarbook