08
Eki
2025

Veri yapıları ve algoritmalar II – Bağlı liste

 

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);
    //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ü bağlı 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çelirini 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 iste 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);
  //gosterici = ekle(kok, gosterici, 40);
  
  // Listeyi yazdýr
  //yazdir(kok);
  
  // Listede deðer ara
  //ileriara(kok, 40);
  //ara(kok, 20);
  
  // 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);
  
  //kok = sil(kok, 30);
  // Listeyi yazdýr
  yazdir(kok);
  
  
  //gosterici = ekle(kok, gosterici, 50);
  //yazdir(kok);	
}

 

error: içerik koruması