25.09.2024
Binary search (ikili arama) algoritması için derste yazdığımız kaynak kod.
#include <iostream>
using namespace std;
int ikiliArama(int dizi[], int sol, int sag, int aranan)
{
if (sag>=sol)
{
int orta = sol + (sag - sol)/2;
if (dizi[orta]==aranan)
{
return orta;
}
if (dizi[orta]>aranan)
{
return ikiliArama(dizi, sol, orta-1, aranan);
}
else
{
return ikiliArama(dizi, orta+1, sag, aranan);
}
}
else
{
return -1;
}
}
int main()
{
int elemansayisi = 10;
int yeni[elemansayisi] = {2, 3, 6, 8, 12, 50, 60, 72, 88, 99};
cout<<ikiliArama(yeni, 0, elemansayisi, 72);
return 0;
}
02.10.2024
Sıralama algoritmaları
#include<iostream>
using namespace std;
// Kabarcık sıralama *************************************************************************
void bubbleSort(int dizi[], int n)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n-1; j++)
if (dizi[j] > dizi[j+1])
{
int temp = dizi[j];
dizi[j] = dizi[j+1];
dizi[j+1] = temp;
}
}
// Yerleştirmeli sıralama *************************************************************************
void insertionSort(int dizi[], int n)
{
int i, j, anahtar;
for(i = 1; i<n; i++)
{
anahtar = dizi[i];
j = i-1;
while(j>=0 && dizi[j]>anahtar)
{
dizi[j+1] = dizi[j];
j = j-1;
}
dizi[j+1] = anahtar;
}
}
// Seçmeli sıralama *************************************************************************
void selectionSort(int arr[], int n)
{
int enkucuk, yedek;
for (int i = 0; i < n-1; i++)
{
enkucuk = i;
for (int j = i+1; j < n; j++)
{
if (arr[j]<arr[enkucuk])
{
enkucuk = j;
}
}
if (enkucuk != i)
{
yedek = arr[i];
arr[i] = arr[enkucuk];
arr[enkucuk] = yedek;
}
}
}
// Kabuk sıralama *************************************************************************
void shellSort(int dizi[], int n)
{
for (int a = n / 2; a > 0; a /= 2)
{
for (int i = a; i < n; i += 1)
{
int temp = dizi[i];
int j;
for (j = i; j >= a && dizi[j - a] > temp; j -= a) {
dizi[j] = dizi[j - a];
}
dizi[j] = temp;
}
}
}
// Hızlı sıralama *************************************************************************
int bolumlendir (int dizi[], int kucuk, int buyuk)
{
int pivot = dizi[buyuk]; // pivot
int i = (kucuk - 1); // Index of smaller element and indicates the right position of pivot found so far
for (int j = kucuk; j <= buyuk - 1; j++)
{
// If current element is smaller than the pivot
if (dizi[j] < pivot)
{
i++; // increment index of smaller element
int temp = dizi[i];
dizi[i] = dizi[j];
dizi[j] = temp;
}
}
int temp = dizi[i+1];
dizi[i+1] = dizi[buyuk];
dizi[buyuk] = temp;
return (i + 1);
}
void quickSort(int dizi[], int kucuk, int buyuk)
{
if (kucuk < buyuk)
{
int pi = bolumlendir(dizi, kucuk, buyuk);
quickSort(dizi, kucuk, pi - 1);
quickSort(dizi, pi + 1, buyuk);
}
}
//*******************************************************************************
main()
{
int dizi[5] = {10, 6, 8, 11, 2};
bubbleSort(dizi, 5);
insertionSort(dizi, 5);
selectionSort(dizi, 5);
shellSort(dizi,5);
quickSort(dizi, 0, 4);
for(int i = 0; i<5; i++)
cout<<dizi[i]<<" ";
}
23.10.2024
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ç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. 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);
//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);
}
27.11.2024
Yığın
#include<iostream>
#include <locale.h>
using namespace std;
// Yığın veri yapısı
struct stack{
int boyut;
int *elemanlar;
int ust;
};
// Yeni bir yığın oluşturma fonksiyonu
stack* createStack(int boyut)
{
stack *yigin = new stack;
yigin->boyut = boyut;
yigin->ust = -1;
yigin->elemanlar = new int[boyut];
return yigin;
}
// Yığın boş mu?
bool isEmpty(stack &yigin)
{
if (yigin.ust == -1)
return true;
else
return false;
}
//Yığın dolu mu?
bool isFull(stack &yigin)
{
if (yigin.ust == yigin.boyut-1)
return true;
else
return false;
}
// Yığına eleman ekle
bool push(stack &yigin, int veri)
{
if (isFull(yigin) == false)
{
yigin.elemanlar[++yigin.ust] = veri;
cout<<yigin.elemanlar[yigin.ust]<<" eklendi. Yeni üst:"<<yigin.ust<<endl;
return true;
}
cout<<"Yığın dolu";
return false;
}
// Yığından eleman çıkarma
bool pop(stack &yigin)
{
if (isEmpty(yigin) == false)
{
cout<<yigin.elemanlar[yigin.ust]<<" çıkarıldı"<<endl;
yigin.elemanlar[yigin.ust--] = NULL;
return true;
}
cout<<"Yığın zaten boş"<<endl;
return false;
}
// En üst elemanı yazdırma
void peek(stack &yigin)
{
cout<<"En üst eleman: "<<yigin.elemanlar[yigin.ust]<<", en üst indeks: "<<yigin.ust<<endl;
}
// Tüm yığını ekrana yazdır.
void display(stack &yigin)
{
if (isEmpty(yigin) == false)
{
for (int i = 0; i<=yigin.ust; i++)
cout<<yigin.elemanlar[i]<<endl;
}
else cout<<"Yığın boş";
}
main()
{
setlocale(LC_ALL, "Turkish");
// Başlangıç adresi yigin olan 10 elemanlı bir integer yığını oluşturulsun
stack *yigin = createStack(10);
// Yığın dolu mu?
//cout<<isEmpty(*yigin);
// Yığın boş mu?
//cout<<isFull(*yigin);
// Ekleme
push(*yigin, 23);
push(*yigin, 21);
push(*yigin, 13);
push(*yigin, 3);
push(*yigin, 11);
push(*yigin, 15);
display(*yigin);
pop(*yigin);
pop(*yigin);
peek(*yigin);
pop(*yigin);
pop(*yigin);
pop(*yigin);
pop(*yigin);
pop(*yigin);
pop(*yigin);
}
Kuyruk
#include<iostream>
#include <locale.h>
using namespace std;
// kuyruk veri yapısı
struct queue{
int boyut;
int *elemanlar;
int ust;
};
// Yeni bir kuyruk oluşturma fonksiyonu
queue* createqueue(int boyut)
{
queue *kuyruk = new queue;
kuyruk->boyut = boyut;
kuyruk->ust = -1;
kuyruk->elemanlar = new int[boyut];
return kuyruk;
}
// kuyruk boş mu?
bool isEmpty(queue &kuyruk)
{
if (kuyruk.ust == -1)
return true;
else
return false;
}
//kuyruk dolu mu?
bool isFull(queue &kuyruk)
{
if (kuyruk.ust == kuyruk.boyut-1)
return true;
else
return false;
}
// kuyruğa eleman ekle
bool enqueue(queue &kuyruk, int veri)
{
if (isFull(kuyruk) == false)
{
kuyruk.elemanlar[++kuyruk.ust] = veri;
cout<<kuyruk.elemanlar[kuyruk.ust]<<" eklendi. Yeni üst:"<<kuyruk.ust<<endl;
return true;
}
cout<<"kuyruk dolu";
return false;
}
// kuyruktan eleman çıkarma
bool dequeue(queue &kuyruk)
{
if (isEmpty(kuyruk) == false)
{
cout<<kuyruk.elemanlar[0]<<" çıkarıldı"<<endl;
for(int i=0;i<=kuyruk.ust;i++)
{
kuyruk.elemanlar[i] = kuyruk.elemanlar[i+1];
}
kuyruk.ust--;
return true;
}
cout<<"kuyruk zaten boş"<<endl;
return false;
}
// En üst elemanı yazdırma
void peek(queue &kuyruk)
{
cout<<"En üst eleman: "<<kuyruk.elemanlar[0]<<", en üst indeks: "<<kuyruk.ust<<endl;
}
// Tüm kuyruğu ekrana yazdır.
void display(queue &kuyruk)
{
if (isEmpty(kuyruk) == false)
{
for (int i = 0; i<=kuyruk.ust; i++)
cout<<kuyruk.elemanlar[i]<<endl;
}
else cout<<"kuyruk boş";
}
main()
{
setlocale(LC_ALL, "Turkish");
// Başlangıç adresi kuyruk olan 10 elemanlı bir integer kuyruğu oluşturulsun
queue *kuyruk = createqueue(10);
// kuyruk dolu mu?
//cout<<isEmpty(*kuyruk);
// kuyruk boş mu?
//cout<<isFull(*kuyruk);
// Ekleme
enqueue(*kuyruk, 23);
enqueue(*kuyruk, 21);
enqueue(*kuyruk, 13);
enqueue(*kuyruk, 3);
enqueue(*kuyruk, 11);
enqueue(*kuyruk, 15);
display(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
peek(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
dequeue(*kuyruk);
}
11.12.2024
İkili arama ağacı
#include<iostream>
using namespace std;
// Ağaç düğümü yapısının tanımlanması
struct dugum{
int ID;
dugum *sol;
dugum *sag;
};
// Yeni düğüm ekleme
dugum *ekle(dugum *kok, int veri)
{
if (kok == NULL)
{
dugum *yeni = new dugum;
yeni->sag = NULL;
yeni->sol = NULL;
yeni->ID = veri;
return yeni;
}
if (veri < kok->ID)
{
kok->sol = ekle(kok->sol, veri);
return kok;
}
else if (veri >= kok->ID)
{
kok->sag = ekle(kok->sag, veri);
return kok;
}
}
// Ağacı dolaşma (traverse)
void dolas(dugum *kok)
{
if (kok == NULL)
cout<<"bos";//return;
else
{
/* 1. seçenek infix: LNR veya RNL (kök ortada)
// işlem
dolas(kok->sol);
dolas(kok->sag);*/
/* 2 seçenek prefix: NLR veya NRL (kök başta)
// işlem
dolas(kok->sol);
dolas(kok->sag);*/
// 3. seçenek postfix: LRN veya RLN (kök sonda)
dolas(kok->sol);
dolas(kok->sag);
// işlem
}
}
// Ağacı listeleme
void listele(dugum *kok)
{
if (kok == NULL)
{
return;
}
else
{
// 1. seçenek infix: LNR veya RNL (kök ortada)
listele(kok->sol);
cout<<kok->ID<<" ";
listele(kok->sag);
/* 2 seçenek prefix: NLR veya NRL (kök başta)
cout<<kok->ID<<" ";
listele(kok->sol);
listele(kok->sag);*/
/* 3. seçenek postfix: LRN veya RLN (kök sonda)
listele(kok->sol);
listele(kok->sag);
cout<<kok->ID<<" ";*/
}
}
// Arama
bool ara(dugum *kok, int aranan)
{
if (kok->ID == aranan)
{
return true;
}
if (kok == NULL)
{
return false;
}
if (aranan < kok->ID)
ara(kok->sol, aranan);
if (aranan >= kok->ID)
ara(kok->sag, aranan);
}
// Maksimum değer bulma
int maks(dugum *kok)
{
while (kok->sag != NULL)
kok = kok->sag;
return kok->ID;
}
// Minimum değer bulma
int min(dugum *kok)
{
while (kok->sol != NULL)
kok = kok->sol;
return kok->ID;
}
// Silme işlemi
dugum* sil(dugum *kok, int silinecek)
{
if (kok == NULL)
return NULL;
else if (kok->ID == silinecek)
{
if ((kok->sag == NULL) && (kok->sol == NULL)) // Aranan veri bir yapraktaysa, yani sol ve sağ bağlantıları boşsa düğümü sil
{
delete(kok);
return NULL;
}
// Eğer arada bir düğüm silinecekse;
//Ya o düğümün sol altındaki en büyük düğüm silinen düğümün yerine gelir
// Ya da o düğümün sağ altındaki en küçük düğüm silinen düğümün yerine gelir.
if (kok->sag!=NULL) // Düğümün sağ bağlantısı doluysa sağdaki en küçük düğümü getir
{
kok->ID = min(kok->sag);
kok->sag = sil(kok->sag, min(kok->sag));
return kok;
}
else if (kok->sol!=NULL) // Sağ bağlantısı boş ve sol bağlantısı doluysa soldaki en büyük düğümü getir
{
kok->ID = maks(kok->sol);
kok->sol = sil(kok->sol, maks(kok->sol));
return kok;
}
}
else if (silinecek >= kok->ID) // Silinecek değer düğümden büyük eşitse sağdan devam et
{
sil(kok->sag, silinecek);
}
else if (silinecek< kok->ID) // Silinecek değer düğümden küçükse soldan devam et
{
sil(kok->sol, silinecek);
}
}
main()
{
// Yeni ağaç oluştur
dugum *kok = new dugum;
kok = NULL;
// Ağaca düğümler ekle
kok = ekle(kok, 23);
kok = ekle(kok, 12);
kok = ekle(kok, 9);
kok = ekle(kok, 33);
kok = ekle(kok, 41);
//Ağacı listele
listele(kok);
int arananSayi = 41;
if (ara(kok, arananSayi) == true ) cout<<arananSayi<<" bulundu"<<endl;
else cout<<arananSayi<<" bulunmadi"<<endl;
cout<<"en buyuk: "<<maks(kok)<<endl;
cout<<"en kucuk: "<<min(kok)<<endl;
sil(kok, 33);
listele(kok);
}