11
May
2023

Veri yapıları ve algoritmalar dersi bağlı liste C++ kodları

Tek yönlü bağlı liste

 #include<iostream>
using namespace std;

// DÜĞÜM YAPISINI TANIMLAMA**************************************************************************************
struct dugum{
  int ID;
  dugum *sonraki;
};


// BAĞLI LİSTEYE DÜĞÜM EKLEME**************************************************************************************
// Fonksiyon kök ve iterator işaretçilerini alır. Eğer iterator == NULL ise liste boştur. 
// Liste boş değilse yeni düğüm eklenir ve sonrakisi NULL yapılır. İterator son düğümü gösterecek şekilde döndürülür.
dugum *ekle(dugum *kok, dugum *adres, int veri)
{
    if (adres==NULL) // Liste boş. Gelen adres verisi kök adresini gösteriyor
    {
      kok->ID = veri; 
      kok->sonraki = NULL;
      cout<<veri<<" eklendi."<<endl;
      return kok; // Kökün gösterdiği ilk eleman yazıldı. Gösterici artık o elemanı gösteriyor			
    }
    else if(adres->sonraki == NULL)    // Gösterici son elemanda, düğümü sona ekliyoruz ve göstericiyi yeni düğüme işaretliyoruz
    {
      dugum *yeni = new dugum;
      adres->sonraki = yeni;
      yeni->ID = veri;
      yeni->sonraki = NULL;
      cout<<veri<<" eklendi."<<endl;
      return adres->sonraki;
    }
    else // Göstericinin gösterdiği araya eleman ekliyoruz
    {
      dugum *yeni = new dugum;
      yeni->sonraki = adres->sonraki;
      adres->sonraki = yeni;
      yeni->ID = veri;
      cout<<veri<<" eklendi."<<endl;
      return adres->sonraki;
    }
}

// BAĞLI LİSTEDEN DÜĞÜM SİL**************************************************************************************
dugum* sil(dugum* adres ,int veri)
{
  if (adres->ID == veri) // Silinecek düğüm ilk sırada iste silme sonrasında kök adres değişecek
  {
    dugum *temp = adres;
    adres = adres->sonraki;
    delete(temp);
    cout<<veri<<" ilk dugumdeydi ve silindi."<<endl;
    return adres; // Kök adresi değişti.
  }
  else // Listede birden fazla düğüm varsa
  {
    dugum *oncekiDugum = NULL;
    dugum *kok = adres;
    while (adres!= NULL) // Silinecek düğümü bulmak için aramaya başla
    {				
      if (adres->ID == veri) // Düğüm bulundu mu?
      {
        oncekiDugum->sonraki = adres->sonraki;	
        delete(adres);
        cout<<veri<<" silindi."<<endl;
        return kok;
      }
      oncekiDugum = adres;
      adres = adres->sonraki;	
    }
    return kok;
  }	
}

// BAĞLI LİSTEYİ YAZDIR**************************************************************************************
// Kök ve iterator bilgisini parametre olarak alır. İterator boşsa liste boştur.
// Aksi halde iterator->sonraki NULL olana kadar liste yazdırılır. 
void yazdir(dugum *adres)
{
  if (adres==NULL) 
  {
    cout<<"Liste bos"<<endl;
  }
  else
  {
    while(adres!=NULL)
   	{
      cout<<adres->ID<<endl;
      adres = adres->sonraki;
    }
  }	
}

// BAĞLI LİSTEDE ARAMA**************************************************************************************
// Kökten başlayarak sona ilerler ve anahtarın kaçıncı sırada olduğunu arar.
// Anahtarı bulursa iteratorü anahtarın bulunduğu düğüme getirir.
dugum *ara(dugum *adres, int veri)
{
  int siraNo = 0;
  while(adres!=NULL)
  {
    siraNo++;
    if (adres->ID == veri)
    {
      cout<<"Aranan veri "<<siraNo<<".dugumde"<<endl;
      return adres;
    }	
    adres = adres->sonraki;
  }
  cout<<"Veri bulunamadi."<<endl;
  return NULL;
}

int main()
{
  // Yeni bağlı liste oluştur
  dugum *kok = new dugum;
  kok->sonraki = NULL;
  
  // İşlem yapacağımız düğüm bilgisi için bir iterator oluşturuyoruz
  // Bu iterator ile bir düğümü işaret edersek o düğümden sonra araya düğüm ekleyebiliriz.
  dugum *gosterici = NULL;
  
  // Örnek düğümler ekle
  gosterici = ekle(kok, gosterici, 10);
  gosterici = ekle(kok, gosterici, 20);
  gosterici = ekle(kok, gosterici, 30);
  gosterici = ekle(kok, gosterici, 40);
  
  // Listeyi yazdır
  yazdir(kok);
  
  // Listede değer ara
  ara(kok, 11);
  ara(kok, 20);
  
  // Listeden düğüm sil
  kok = sil(kok, 10);
  kok = sil(kok, 30);
  // Listeyi yazdır
  yazdir(kok);
  
  gosterici = ekle(kok, gosterici, 50);
  yazdir(kok);	
}

Dairesel bağlı liste

#include<iostream>
using namespace std;

// DÜĞÜM YAPISINI TANIMLAMA**************************************************************************************
struct dugum{
    int ID;
    dugum *sonraki;
};

// BAĞLI LİSTEYE DÜĞÜM EKLEME**************************************************************************************
// Fonksiyon kök ve iterator işaretçilirini alır. Eğer iterator == NULL ise liste boştur.
// Liste boş değilse yeni düğüm eklenir ve sonrakisi NULL yapılır. İterator son düğümü gösterecek şekilde döndürülür.
dugum *ekle(dugum *kok, dugum *adres, int veri)
{
        if (adres==NULL) // Liste boş. Gelen adres verisi kök adresini gösteriyor
        {
            kok->ID = veri;
            kok->sonraki = kok;
            cout<<veri<<" eklendi."<<endl;
            adres = kok;
            return kok; // Kökün gösterdiği ilk eleman yazıldı. Gösterici artık o elemanı gösteriyor
        }
        else // Göstericinin gösterdiği araya eleman ekliyoruz
        {
            dugum *yeni = new dugum;
            yeni->sonraki = adres->sonraki;
            adres->sonraki = yeni;
            yeni->ID = veri;
            cout<<veri<<" eklendi."<<endl;
            return adres->sonraki;
        }
}

// BAĞLI LİSTEDEN DÜĞÜM SİL**************************************************************************************
dugum* sil(dugum* adres ,int veri)
{
    // Listede tek düğüm varsa
    if (adres == adres->sonraki)
    {
        if (adres->ID == veri)
        {
            delete(adres);
            cout<<veri<<" ilk dugumdeydi ve silindi."<<endl;
            return NULL;
        }
        else cout<<"Bulunamadi";
    }
    else // Listede birden fazla düğüm var
    {
        dugum *oncekiDugum = adres;
        dugum *kok = adres;
        adres = adres->sonraki;
        do// Silinecek düğümü bulmak için aramaya başla
        {
            if (adres->ID == veri) // Düğüm bulundu mu?
            {
                oncekiDugum->sonraki = adres->sonraki;
                if (adres!=kok) // kökü gösteren eleman silinmedi
                {
                    delete(adres);
                    return kok;
                }
                else  // Kökü gösteren eleman silindi. Kök bir sağdaki elemana kayacak
                {
                    delete(adres);
                    return oncekiDugum->sonraki;
                }
                cout<<veri<<" silindi."<<endl;
            }
            oncekiDugum = adres;
            adres = adres->sonraki;
        }while (adres!= kok->sonraki);
        return kok;
    }
}

// BAĞLI LİSTEYİ YAZDIR**************************************************************************************
// Kök ve iterator bilgisini parametre olarak alır. İterator boşsa liste boştur.
// Aksi halde iterator->sonraki NULL olana kadar liste yazdırılır.
void yazdir(dugum *adres)
{
    dugum* baslangic = adres; // Listenin başındaki düğümün adresini hafızaya al, o adrese dönene kadar listeyi yazdıracağız
    if (adres==NULL)
    {
        cout<<"Liste bos"<<endl;
    }
    else
    {
        do
         {
            cout<<adres->ID<<endl;
            adres = adres->sonraki;
        }while(adres!=baslangic);
    }
    
}

// BAĞLI LİSTEDE ARAMA**************************************************************************************
// Kökten başlayarak sona ilerler ve anahtarın kaçıncı sırada olduğunu arar.
// Anahtarı bulursa iteratorü anahtarın bulunduğu düğüme getirir.
dugum *ara(dugum *adres, int veri)
{
    int siraNo = 0;
    dugum* baslangic = adres; // Listenin başındaki düğümün adresini hafızaya al, o adrese dönene kadar listeyi yazdıracağız
    do
    {
        siraNo++;
        if (adres->ID == veri)
        {
            cout<<"Aranan veri "<<siraNo<<".dugumde"<<endl;
            return adres;
        }
        adres = adres->sonraki;
    }while((adres!=NULL) && (baslangic!=adres));
    cout<<"Veri bulunamadi."<<endl;
    return NULL;
}

int main()
{
    // Yeni bağlı liste oluştur
    dugum *kok = new dugum;
    kok->sonraki = NULL;
    
    // İşlem yapacağımız düğüm bilgisi için bir iterator oluşturuyoruz
    // Bu iterator ile bir düğümü işaret edersek o düğümden sonra araya düğüm ekleyebiliriz.
    dugum *gosterici = NULL;
    
    // Örnek düğümler ekle
    gosterici = ekle(kok, gosterici, 10);
    gosterici = ekle(kok, gosterici, 20);
    gosterici = ekle(kok, gosterici, 30);
    gosterici = ekle(kok, gosterici, 40);
    
    // Listeyi yazdır
    yazdir(kok);
    
    // Listede değer ara
    ara(kok, 20);
       
    // Listeden düğüm sil
    cout<<"silme"<<endl;
    kok = sil(kok, 10);
    kok = sil(kok, 30);

    gosterici = ekle(kok, gosterici, 50);
    yazdir(kok);
}

Çift yönlü liste

#include<iostream>
using namespace std;

// DÜĞÜM YAPISINI TANIMLAMA**************************************************************************************
struct dugum{
    int ID;
    dugum *sonraki;
    dugum *onceki;
};

// BAĞLI LİSTEYE DÜĞÜM EKLEME**************************************************************************************
// Fonksiyon kök ve iterator işaretçilerini alır. Eğer iterator == NULL ise liste boştur.
// Liste boş değilse yeni düğüm eklenir ve sonrakisi NULL yapılır. iterator son düğümü gösterecek şekilde döndürülür.
dugum *ekle(dugum *kok, dugum *adres, int veri)
{
        if (adres==NULL) // Liste boş. Gelen adres verisi kök adresini gösteriyor
        {
            kok->ID = veri;
            kok->sonraki = NULL;
            kok->onceki = kok;
            cout<<veri<<" eklendi."<<endl;
            return kok; // Kökün gösterdiği ilk eleman yazıldı. Gösterici artık o elemanı gösteriyor
        }
        else if(adres->sonraki == NULL)    // Gösterici son elemanda, düğümü sona ekliyoruz ve göstericiyi yeni düğüme işaretliyoruz
        {
            dugum *yeni = new dugum;
            adres->sonraki = yeni;
            yeni->ID = veri;
            yeni->sonraki = NULL;
            yeni->onceki = adres;
            cout<<veri<<" eklendi."<<endl;
            return adres->sonraki;
        }
        else // Göstericinin gösterdiği araya eleman ekliyoruz
        {
            dugum *yeni = new dugum;
            yeni->sonraki = adres->sonraki;
            yeni->sonraki->onceki = yeni;
            yeni->onceki = adres;
            adres->sonraki = yeni;
            yeni->ID = veri;
            cout<<veri<<" eklendi."<<endl;
            return adres->sonraki;
        }
}

// BAĞLI LİSTEDEN DÜĞÜM SİL**************************************************************************************
dugum* sil(dugum* adres ,int veri)
{
    if (adres->ID == veri) // Silinecek düğüm ilk sırada ise silme sonrasında kök adres değişecek
    {
        if (adres->sonraki==NULL) // Listede tek düğüm var
        {
            delete adres;
            cout<<"liste silindi"<<endl;
            return NULL;
        }
        else  // Listede başka düğümler de var ama ilk düğüm silinecek
        {
            dugum *temp = adres;
            adres = adres->sonraki;
            adres->onceki = adres;
            delete(temp);
            cout<<veri<<" ilk dugumdeydi ve silindi."<<endl;
            return adres; // Kök adresi değişti.
        }
    }
    else // Listede birden fazla düğüm varsa
    {
        dugum *oncekiDugum = NULL;
        dugum *kok = adres;
        while (adres!= NULL) // Silinecek düğümü bulmak için aramaya başla
        {
            if (adres->ID == veri) // Düğüm bulundu mu?
            {
                oncekiDugum->sonraki = adres->sonraki;
                adres->sonraki->onceki = oncekiDugum;
                delete(adres);
                cout<<veri<<" silindi."<<endl;
                return kok;
            }
            oncekiDugum = adres;
            adres = adres->sonraki;
        }
        return kok;
    }
}

// BAĞLI LİSTEYİ YAZDIR**************************************************************************************
// Kök ve iterator bilgisini parametre olarak alır. İterator boşsa liste boştur.
// Aksi halde iterator->sonraki NULL olana kadar liste yazdırılır.
void yazdir(dugum *adres)
{
    if (adres==NULL)
    {
        cout<<"Liste bos"<<endl;
    }
    else
    {
        while(adres!=NULL)
         {
            cout<<adres->ID<<endl;
            adres = adres->sonraki;
        }
    }
    
}

// BAĞLI LİSTEDE ARAMA**************************************************************************************
// Kökten başlayarak sona ilerler ve anahtarın kaçıncı sırada olduğunu arar.
// Anahtarı bulursa iteratorü anahtarın bulunduğu düğüme getirir.
dugum *ileriara(dugum *adres, int veri)
{
    int siraNo = 0;
    while(adres!=NULL)
    {
        siraNo++;
        if (adres->ID == veri)
        {
            cout<<"Aranan veri "<<siraNo<<".dugumde"<<endl;
            return adres;
        }
        adres = adres->sonraki;
    }
    cout<<"Veri bulunamadi."<<endl;
    return NULL;
}

dugum *geriara(dugum *kok, dugum *son, int veri)
{
    int siraNo = 0;
    dugum *gosterici = son;
    while(gosterici!=kok)
    {
        siraNo++;
        if (gosterici->ID == veri)
        {
            cout<<"Aranan veri "<<siraNo<<".dugumde"<<endl;
            return gosterici;
        }
        gosterici = gosterici->onceki;
    }
    cout<<"Veri bulunamadi."<<endl;
    return NULL;
}

int main()
{
    // Yeni bağlı liste oluştur
    dugum *kok = new dugum;
    kok->sonraki = NULL;
    
    // İşlem yapacağımız düğüm bilgisi için bir iterator oluşturuyoruz
    // Bu iterator ile bir düğümü işaret edersek o düğümden sonra araya düğüm ekleyebiliriz.
    dugum *gosterici = NULL;
    
    // Örnek düğümler ekle
    gosterici = ekle(kok, gosterici, 10);
    gosterici = ekle(kok, gosterici, 20);
    gosterici = ekle(kok, gosterici, 30);
    
    // Listeyi yazdır
    yazdir(kok);
    
    // Listede değer ara
    ileriara(kok, 40);
    
    
    // Geri arama için önce listenin sonuna git
    dugum *son;
    son = kok;
    while(son->sonraki!=NULL) son = son->sonraki;
    geriara(kok, son, 30);
    
    // Listeden düğüm sil
    kok = sil(kok, 10);
    kok = sil(kok, 20);
    kok = sil(kok, 30);
    
    // Listeyi yazdır
    yazdir(kok);
    
    gosterici = ekle(kok, gosterici, 50);
    yazdir(kok);
}

 

%d blogcu bunu beğendi: