Haftanın Fragmanı

Bu hafta oyun tanıtım rehberlerimiz başlıyor .Dreamweaver,PhotoShop vb. Derslerimizin videoları paylaşıma açılacak.Yazarlarımızdan gelen video,köşe yazısı gibi içerikleri sitemizde derleyip yayınlıyoruz.Sitemizde Yayın yapmak isteyenler Bizlerle iletişime Geçsinler.

Opencore | Açık Çekirdek Platformu

Yeni sayfanın başlığıq

// C++ B-Tree(B Ağaçları) Proje odevi
#include<iostream>
using namespace std;

// B Ağaçları Örnek
class BAgaclari
{
	int *keys; // Dizi Anahtarı
	int t;	 // Minimum derece (anahtar sayısının aralığını tanımlar)
	BAgaclari **C; // Bir dizi alt işaretçisi
	int n;	 // Geçerli anahtar sayısı
	bool yaprak; // düğüm yaprak ise geçerlidir. Aksi takdirde gecerli değildir.
public:
	BAgaclari(int _t, bool _yaprak); // Nesne Kurucu

	void doluDegilseEkleme(int k);
	void bolDugum(int i, BAgaclari *y);
	// Bu düğümle kök salmış bir alt ağacın tüm düğümlerini yedeklem bir işlev
	void capraz();

	// Bu düğümle kök dizilmiş alt ağacında bir anahtar arama fonksiyonu.
	BAgaclari *arama(int k); // k yoksa NULL döndürür.

// BAgac arkadaşını, bunun özel üyelerine erişebilmemiz için 
// BAgac işlevlerinde sınıf
friend class BAgac;
};
//BAgac
class BAgac
{
	BAgaclari *root; // Kök düğüm için işaretçi
	int t; // Minimum derece
public:
	// Nesne Kurucu
	BAgac(int _t)
	{ root = NULL; t = _t; }
	void capraz()
	{ if (root != NULL) root->capraz(); }

	// Bu ağaçta bir anahtar aramak için işlev
	BAgaclari* arama(int k)
	{ return (root == NULL)? NULL : root->arama(k); }

	// Bu B-Ağacına yeni bir anahtar ekleyen ana işlevi
	void ekleme(int k);
};

// Nesne Kurucu BAgaclari sınıfı için
BAgaclari::BAgaclari(int t1, bool yaprak1)
{
	// Verilen varsayilan derece ve yaprak özelliklerini kopyala
	t = t1;
	yaprak = yaprak1;

	// Maksimum sayıda olası anahtar için bellek ayırma
	// ve çocuk işaretçiler
	keys = new int[2*t-1];
	C = new BAgaclari *[2*t];
	// baslangic sayısını 0 olarak başlat
	n = 0;
}

// tüm düğümleri kapsayan işlev sıralama
void BAgaclari::capraz()
{
	int i;
	for (i = 0; i < n; i++)
	{
		if (yaprak == false)
			C[i]->capraz();
		cout << " " << keys[i];
	}

	// Son çocuğu suBAgac yazdır
	if (yaprak == false)
		C[i]->capraz();
}

// Bu düğümün alt kökündeki dügüme anahtar k'yı arama işlevi
BAgaclari *BAgaclari::arama(int k)
{
	// K'den büyük veya ona eşit olan ilk anahtarı bulun
	int i = 0;
	while (i < n && k > keys[i])
		i++;

	// Bulunan anahtar k'ye eşitse, bu düğümü döndür
	if (keys[i] == k)
		return this;

	// Burada anahtar bulunmazsa null dondur
	if (yaprak == true)
		return NULL;
	return C[i]->arama(k);
}

// Bu B-Ağacına yeni bir anahtar ekleyen ana işlevi
void BAgac::ekleme(int k)
{
	// Ağaç boş ise
	if (root == NULL)
	{
		//bellek ata
		root = new BAgaclari(t, true);
		root->keys[0] = k; // Eklenecek key
		root->n = 1; // Kökte anahtar sayısını güncelle
	}
	else // Ağaç boş değilse
	{
		// Eğer kök doluysa, ağaç yükseklik artar
		if (root->n == 2*t-1)
		{
			// Yeni root için bellek ayırın
			BAgaclari *s = new BAgaclari(t, false);

			// Eski kökü yeni kökün çocuğu yap
			s->C[0] = root;

			// Eski kök bölünür ve 1 anahtarını yeni kök olarak taşır
			s->bolDugum(0, root);
			int i = 0;
			if (s->keys[0] < k)
				i++;
			s->C[i]->doluDegilseEkleme(k);

			// seçili root (kök)
			root = s;
		}
		else 
			root->doluDegilseEkleme(k);
	}
}

// Bu düğüme yeni bir anahtar eklemek için bir yardımcı program işlevi
// Varsayalım, bu olduğunda düğüm dolu olmamalıdır.
// doluDegilseEkleme işlevi çağrılır
void BAgaclari::doluDegilseEkleme(int k)
{
	// En son elemanın indeksi olarak dizini başlatır
	int i = n-1;

	// Eğer bu bir yaprak düğümüyse
	if (yaprak == true)
	{
// Aşağıdaki döngü iki şey yapar
// a) Eklenecek yeni anahtarın konumunu bulur
// b) Tüm büyük dügüm ileride bir yere taşıyın
		while (i >= 0 && keys[i] > k)
		{
			keys[i+1] = keys[i];
			i--;
		}

		// Yeni anahtarı bulunan konuma ekle
		keys[i+1] = k;
		n = n+1;
	}
	else // Bu düğüm yaprak değilse
	{
		// Yeni anahtara sahip olacak çocuğu bul
		while (i >= 0 && keys[i] > k)
			i--;

		// Bulunan çocuğun dolu olup olmadığına bak
		if (C[i+1]->n == 2*t-1)
		{
			// Çocuk doluysa, bölün.
			bolDugum(i+1, C[i+1]);

// Ayrıldıktan sonra C [i] nin orta tuşu yukarı gider ve
// C [i] ikiye bölünür. Ikisinin hangisinin olduğunu görün
// yeni anahtara sahip olacak

			if (keys[i+1] < k)
				i++;
		}
		C[i+1]->doluDegilseEkleme(k);
	}
}

// Bu düğümün çocuğunu bölmek için bir yardımcı program işlevi
// Bu işlev çağrıldığında y'nin dolu olması gerektiğini unutmayın
void BAgaclari::bolDugum(int i, BAgaclari *y)
{
// Saklanacak yeni bir düğüm oluştur (t-1) tuşları
// y
	BAgaclari *z = new BAgaclari(y->t, y->yaprak);
	z->n = t - 1;

// y'nin son (t-1)  z'ye kopyala

	for (int j = 0; j < t-1; j++)
		z->keys[j] = y->keys[j+t];

// y'nin son t çocuğunu z'ye kopyala

	if (y->yaprak == false)
	{
		for (int j = 0; j < t; j++)
			z->C[j] = y->C[j+t];
	}

// y'deki key sayısını azalt

	y->n = t - 1;

// Bu düğüm yeni bir çocuğa sahip olacağından,
// yeni çocuk alanı olustur
	for (int j = n; j >= i+1; j--)
		C[j+1] = C[j];

	// Yeni çocuğu bu düğüme bağla
	C[i+1] = z;

// y'nin bir anahtarı bu düğüme taşınacak. Konumunu bulup
// yeni anahtar ve tüm büyük key'i bir boşluk ileri taşıyacak
	for (int j = n-1; j >= i; j--)
		keys[j+1] = keys[j];

	// y'nin orta anahtarını bu düğüme kopyala
	keys[i] = y->keys[t-1];

	// Bu düğümdeki sayım sayısını artırmak
	n = n + 1;
}

// Yukarıdaki işlevleri test etmek için basit girdili programı
int main()
{
	BAgac t(3); // B-Ağacı minium derece 3 ile
	t.ekleme(10);
	t.ekleme(20);
	t.ekleme(5);
	t.ekleme(6);
	t.ekleme(12);
	t.ekleme(30);
	t.ekleme(7);
	t.ekleme(17);

	cout << "Olusturulan agacin ciktisi su sekildedir: ";
	t.capraz();
	return 0;
}

=> Sen de ücretsiz bir internet sitesi kurmak ister misin? O zaman burayı tıkla! <=