Struct ve Pointer Kullanımı Örnek

#include “stdafx.h”
#include “iostream”

struct futbolTakim {
char * takimIsim;
int kurulusYili;
int oynadigiLig;
int ligSirasi;
int sampiyonlukSayisi;
};

int main(){

struct futbolTakim a;
struct futbolTakim *b;

b=&a;

(*b).takimIsim=”besiktas”;
(*b).kurulusYili=1903;
(*b).oynadigiLig=1;
(*b).ligSirasi=1;
(*b).sampiyonlukSayisi=11;

// simdi bu bilgileri ekrana yazdiralim:

cout<< “takim isim:”    <<(*b).takimIsim;
cout<< “kurulus yili:   <<(*b).kurulusYili;
cout<< “oynadigi lig:” <<(*b).oynadigiLig;
cout<< “lig sirasi:”        <<(*b).ligSirasi);
cout<< “sampiyonluk sayisi: ” << (*b).sampiyonlukSayisi);

return 0;
}

Advertisements

Yığın (Stack)

Eleman ekleme çıkarmaların en üstten (top) yapıldığı veri

yapısına yığın (stack) adı verilir. Bir eleman ekleneceğinde

yığının en üstüne konulur. Bir eleman çıkarılacağı zaman

yığının en üstündeki eleman çıkarılır. Bu eleman da yığındaki

elemanlar içindeki en son eklenen elemandır. Bu nedenle

yığınlara LIFO (Last In First Out : Son giren ilk çıkar) listesi

de denilir. C#’ta Yığın yapısı hazır olarak vardır :

(Koleksiyon sınıflarından) Stack sınıfının bazı metotları

  • Push : Yığına (sonuna) eleman ekleyen metot.
  • Pop : Yığıntan (sonundan) eleman silen metot.
  • Eleman ekleme çıkarmaların en üstten (top) yapıldığı veri yapısına yığın (stack) adı verilir.
  • Bir eleman ekleneceğinde yığının en üstüne konulur.
  • Bir eleman çıkarılacağı zaman yığının en üstündeki eleman çıkarılır.
  • Bu eleman da yığıntaki elemanlar içindeki en son eklenen elemandır.
  • Bu nedenle yığınlara LIFO (Last In First Out : Son giren ilk çıkar) listesi de denilir.Yığın Gösterimi
  • (Tanım) Boş yığın (empty stack) : Elemanı olmayan yığın.
  • push (yığına eleman ekleme) : “push(s,i)”, s yığınının en üstüne i değerini eleman olarak ekler.
  • pop (yığıntan eleman çıkarma) : “i = pop(s)”, s yığınının en üstündeki elemanı çıkartır ve değerini i değişkenine atar.
  • empty (yığının boş olup olmadığını belirleyen işlem) : empty(s), yığın boş ise TRUE değerini, değilse FALSE değerini döndürür.
  • stacktop (yığıntan çıkarılmaksızın en üstteki elemanın değerini döndüren işlem, diğer adı peek)
Örnek:
#include “stdafx.h”
#include <iostream>
using namespace std;

#define MAXSIZE 5
//typedef int tam;
struct ornek
{
int dizi[MAXSIZE];// yıgın
int top;          // yıgın indis değişkeni
};
typedef struct ornek orn;
void initStack(orn *p);
void push (orn *p, int yeni_deger);
int pop(orn *p);
int isEmpty(orn *p);
int top(orn ust);
int main()
{
orn a;
int k,i;
initStack(&a);
push(&a,17);
push(&a, 29);
push(&a, 37);
push(&a,49);
for(i=0; i<5; i++)
{
k = pop(&a);
cout << “cıkartılan deger :” << k << endl;
}
for(i=0; i<9; i++)
{
push(&a,i);

}
cin.get();
}

void initStack(orn *p)
{
p->top = -1;
}

void push(orn *p, int yeni_deger)
{
if (isEmpty(p))
{
p->top = p->top + 1;
p->dizi[p->top]= yeni_deger;
}
else cout << “stack dolu\n”;

}

int isEmpty(orn *p)
{
if(p ->top == MAXSIZE)return 0;
return 1;
}

int pop(orn *p)
{
int k;
if (p->top != -1)
{
k = p->dizi[p->top];
(p->top)–;
}
else cout << “stack boş\n”;
return k;
}

int top(orn ust)
{
return ust.dizi[ust.top];
}
/*
int top(orn *ust)
{
return ust->dizi[ust->top];
}  */

Kuyruklar (Queues)

  • Bu bölümde gerçek yaşamdaki kuyrukların bilgisayardaki gösterimleri üzerinde durulacaktır.
  • Kuyruklar, eleman eklemelerin sondan (rear) ve eleman çıkarmaların baştan (front) yapıldığı veri yapılarıdır.
  • Bir eleman ekleneceği zaman kuyruğun sonuna eklenir.
  • Bir eleman çıkarılacağı zaman kuyrukta bulunan ilk eleman çıkarılır.
  • Bu eleman da kuyruktaki elemanlar içinde ilk eklenen elemandır.
  • Bu nedenle kuyruklara FIFO (First-In First-Out = ilk giren ilk çıkar) listeleri de denilmektedir.
  • Gerçek yaşamda da bankalarda, duraklarda, gişelerde, süpermarketlerde, otoyollarda kuyruklar oluşmaktadır.
  • Kuyruğa ilk olarak girenler işlemlerini ilk olarak tamamlayıp kuyruktan çıkarlar.
  • Veri yapılarındaki kuyruklar bu tür veri yapılarının simülasyonunda  kullanılmaktadır.
  • Ayrıca işlemci, yazıcı, disk gibi kaynaklar üzerindeki işlemlerin yürütülmesinde ve bilgisayar ağlarında paketlerin yönlendirilmesinde de kuyruklardan yararlanılmaktadır.
    #include “stdafx.h”
    #include <iostream>
    using namespace std;

    #define MAXSIZE 5
    //typedef int tam;
    struct ornek
    {
    int dizi[MAXSIZE];// kuyruk
    int on;           // kuyrukdan kim çıkacak indis değişkeni
    int arka;         // kuyruğa kim girecek indis değişkeni
    int say;          // kuyrukda kaç kişi var değişkeni
    };
    typedef struct ornek orn;
    void initQueue(orn *p);
    void insert (orn *p, int yeni_deger);
    int remove(orn *p);
    int isEmpty(orn *p);
    int main()
    {
    orn a;
    int i,k;
    initQueue(&a);

    insert(&a, 29);
    k = remove(&a);
    cout << ” cikan kisi = ” << k << endl;

    cout << ” on = ” << a.on << endl;
    cout << ” arka = ” << a.arka << endl;
    cout << ” say = ” << a.say << endl;

    cin.get();
    }// main sonu

    void initQueue(orn *p)
    {
    p->on , p->arka, p->say = 0;
    }

    void insert(orn *p, int yeni_deger)
    {
    if (p->say != MAXSIZE)
    {
    p->dizi[p->arka] = yeni_deger;
    p->arka = (p->arka +1) % MAXSIZE;
    p->say = p->say + 1;
    }
    else cout << “kuyruk dolu\n”;

    }// insert sonu

    int isEmpty(orn p)
    {
    if(p.say == 0 )return 1;
    return 0;
    }//is Empty sonu

    int remove(orn *p)
    {
    int k = 0;
    if (p->say != 0)
    {
    k = p->dizi[p->on];
    p->on = (p->on +1) % MAXSIZE;
    (p->say)–;
    }
    else cout << “kuyruk boş\n”;
    return k;
    }// remove sonu

Tek Yönlü Bağlı Listeler

Bir liste elemanı kendi değerinin yanında bir de sonraki elemana işaret eden bir adres değişkeni içeren bir karmaşık değişken olarak tanımlanmış olmalıdır. C++ dilinde tamsayı değerli bir bağlantılı liste elemanı “struct” adı verilen değişken yapısıyla aşağıdaki gibi tanımlanabilir:

struct eleman
{
int Deger;
struct eleman *pSonraki;
}

#include “stdafx.h”
#include <iostream>
using namespace std;

struct liste
{
int bilgi;
struct liste *link;
};
typedef struct liste list;
list * liste Baslat(int bilgi);
list * elemanOlustur(int yeni_bilgi);
int listeUzunlugu(list *p);
list * basaEkle(list *p, list * yeni_eleman);
void * sonaEkle(list *p, list * yeni_eleman);
void * arayaEkle(list *p, list * yeni_eleman);
void * arayaEkle(list *p, list * yeni_eleman);
list * elemanCıkar(list *p, list * cikan_eleman);
int listeBosMu(list *p);
list * iElemanBul(list *p, int i);
int main()
{

cin.get();
}// main sonu

list * liste Baslat(int bilgi)
{
list *m = (list *)malloc(sizeof(list));
m->link = ”;
m->bilgi = bilgi;
return m;
} // listeBaslat sonu
int * listeUzunlugu(list *p)
{
int i = 1;
list *t = p;
if(t == ”)
{
cout << “Hata! Liste yok\n”;
return -32767;
}
while(t->link != ”)
{
i++;
t = t->link;
}
return i;
}//listeUzunlugu sonu

list * elemanOlustur(int yeni_bilgi)
{
list *eleman = (list *)malloc(sizeof(list));
eleman->bilgi = yeni_bilgi;
eleman->link = ”;
return eleman;
}// eleman olustur sonu
list * basaEkle(list *p, list * yeni_eleman)
{
if(p == ” || yeni_eleman == ”)
{
cout << “hata !! Liste ya da ekelenecek eleman yok\n”;
return p;
}
}// basa ekle sonu
list * sonaEkle(list *p, list * yeni_eleman)
{
list *t = p;
if(t == ” || yeni_eleman == ”)
{
cout << “hata !! Liste ya da ekelenecek eleman yok\n”;
}
else
{
while(t->link != ”)
{
t = t->link;
t->link = yeni_eleman;
}
}
return t;
}// sona ekle sonu
list * arayaEkle(list *p, list * yeni_eleman)
{
if(p == ” || yeni_eleman == ”)
{
cout << “hata !! elemanlardan biri tanımlı değil\n”;
}
else
{
yeni_eleman->link = p->link;
p->link = yeni_eleman;
}
}// araya ekle sonu
list * iElemanBul(list *p, int i)
{
int sira_no = 1;
list *t = p;
if(t == ”)
{
cout << “Hata! Liste tanımlı değil\n”;
return ”;
}
while(t->link != ”)
{
t = t->link;
t->link = yeni_eleman;
}
return t;
}// iElemanBul sonu
list * elemanCıkar(list *p, list * cikan_eleman)
{
list *t = p;
if(cikan_eleman == ” || t == ”)
cout << “Hata! Liste veya cıkacak eleman yok\n”;
else
{
if(t == cikan_eleman)
{
t = t->link;
return t;
}
else
{
while(t->link != cikan_eleman)
{
t = t->link;
if(t == ”)break;
}
if (t == ”)
{
cout << “cıkacak eleman listede yok\n”;
return p;
}
if(t->link == cikan_eleman)
{
t->link = cikan_eleman->link;
free(cikan_eleman);
return p;
}
}
}
}

Struct ve Göstericiler Kullanımı

// struct.cpp : main project file.

#include “stdafx.h”
#include “iostream”
using namespace std;

typedef struct yapi{

int adres;
char adi[25];

}adres_bilgileri;

int main()
{
setlocale(LC_ALL,”Turkish”);
//struct yapi ankara;böylede kullanılabilir.
adres_bilgileri ankara;
adres_bilgileri izmir[3];
adres_bilgileri *ptr;

cout<<“Ankara üyesinin adres nosunu giriniz”;
cin>>ankara.adres;

for(int i=0;i<3;i++){
cout<<“izmir üyesinin adını giriniz”;
cin>>izmir[i].adi;
cout<<“İzmir üyesinin adres nosunu giriniz”;
cin>>izmir[i].adres;
}
izmir[3]=ankara;
ptr=izmir;

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

cout<<“Adı:”<<ptr[i].adi<<“\n”;

cout<<“Adres:” <<ptr[i].adres<<“\n”;
}

return 0;
}