Veri Yapıları - Doubly Linked List

By Burak TUNGUT - 26.11.2012 - 1 Yorum - Kategori C / C++

Bir veri yapıları konusunda daha tekrar beraberiz :) Dün yazdığım Singly Linked List konusunda bir hayli olumlu e-mailler aldığımı söylemeden geçmeyeceğim. Bugün ise dünkü yapımızla neredeyse aynı olan fakat iki yönde de hareket etme kabiliyetine sahip olan Doubly Linked List yapısını göreceğiz.

Küçük farklılıklar, büyük kolaylıklar

Keşke yukarıda yazdığım başlık her konuda geçerli olsa. Ne yazık ki her konuda küçük farklılıklar ile büyük kolaylıklar, kazançlar sağlamak söz konusu olmuyor. Fakat dün derinlemesine bir inceleme yaptığımız singly yapıda hatırlatsanız tek yönde hareket edebiliyorduk çünkü struct içeriğimizde yönümüzü belirleyen tek bir özelliğimiz mevcuttu.
Doubly yapıda ise ismindende anlaşılacağı üzere iki yöndede hareket edebilmek için struct içeriğimizde bir önceki vagonumuzu gösterecek bir özellik daha olacak. Bir önceki makalemizi okumayanlar için hatırlatalım ; biz bir tren yolculuğundayız ve kayıtlarımızda bizler için birer vagon :)

Yapacağımız farklılıklar

Dünki özellikle uzun ekle methodundan sonra size sevindirici birkaç şey söyleyebilirim. Bu yapıda dünki methodları neredeyse aynen kullanacağız. Sadece yeni yapımızda bir önceki kaydıda gösterecek bir özelliğimiz olduğu için sizde takdir edersiniz ki ekleme işleminde sadece bir kaç satır fazla kod yazacağız. Gel gelelim buna rağmen silme işleminde yaptığımız bir önceki kaydı bulma işlemini bu sefer yapmayarak bir hayli işimizi kolaylaştıracağız :)

Yeni Struct'ımız

struct Yapi{
	int Data;
	Yapi* Next;
	Yapi* Back;
};

Dünki yapıdan tek farkı Next de olduğu gibi bir de bir önceki vagonu gösterecek olan Back pointerımızı ekleyip işlemlerimize devam edelim.

Değişiklik göstermeyen kodlarımız

typedef Yapi* ptrType;
ptrType Head;
void Baslat();
void BellekAl(ptrType*);
void BellekBosalt(ptrType);
void Listele();
void Ekle(int,int,bool);
void Bul(int,ptrType*,int*);
void Sil(int);
int main()
{
	Baslat();
	Ekle(1,-1,false);
	Ekle(3,-1,false);
	Ekle(5,-1,false);
	Ekle(7,-1,false);

	Ekle(20,5,false); //5 in soluna 20 ekle
	Sil(5);
}

void Baslat()
{
	Head=NULL;
}

void BellekAl(ptrType* veri)
{
	*veri=(ptrType)malloc(sizeof(Yapi));
}

void BellekBosalt(ptrType veri)
{
	free(veri);
}

void Listele()
{
	ptrType temp = Head;
	while(temp!=NULL)
	{
		printf("\n%x adresindeki deger : %d\n",temp,temp->Data);
		temp=temp->Next;
	}
}

void Bul(int sayi, ptrType* adres, int* sonuc)
{
	*sonuc=-1;
	ptrType temp=Head;
	while(temp!=NULL)
	{
		if(temp->Data == sayi)
		{
			*adres = temp;
			*sonuc=1;
			break;
		}
		temp=temp->Next;
	}
}

Singly yapıya göre hiç bir değişiklik göstermeyen kodlarımız yukarıdaki gibi olacaktır. Geriye sadece Ekle ve Sil methodlarımız kaldı. Bu methodlarımız ise aynı parametreleri aldığı için implementasyonlarıda değişmedi sadece içerikte yapacağımız bir kaç değişiklik içinse hemen onlara bakalım.

Sil Methodu

void Sil(int sayi)
{
	ptrType temp;
	int sonuc;
	Bul(sayi,&temp,&sonuc);
	if(sonuc==1)
	{
		temp->Next->Back=temp->Back;
		temp->Back->Next = temp->Next;
	}
}

Sil methodu değişiklik gösteriyor fakat işimizi kolaylaştıracak yönde olduğu kesin :) Dünki Silme methodunda bir önceki vagonun Next kısmının, sileceğimiz vagondan sonrakini göstermesi gerekiyordu. Bunun için de bir önceki kaydı elde etmemiz gerekiyordu fakat tek yönde hareket etme şansımız olduğu için bir döngü yardımı ile bir önceki kayıda ulaşabiliyorduk.

Doubly yapıda ise Back adında gelen yeni pointerimiz ile bir önceki vagona yukarıdaki gibi ulaşıyoruz ve Next alanını silmek istediğimiz kayıttan sonra gelen kayıt ile değiştiriyoruz.

Efsane Ekle methodumuz

void Ekle(int sayi, int nereye, bool sol)
{
	ptrType temp;
	int sonuc;
	Bul(nereye,&temp,&sonuc);

	ptrType yeni;
	BellekAl(&yeni);
	yeni->Data=sayi;
	if(sonuc==1)
	{
		if(sol)
		{
			yeni->Back=temp->Back;
			yeni->Next = temp;
			temp->Back->Next=yeni;
			temp->Back=yeni;
		}
		else
		{
			yeni->Back=temp;
			yeni->Next=temp->Next;
			temp->Next->Back=yeni;
			temp->Next=yeni;
		}
	}
	if(nereye==-1)
	{
		if(Head!=NULL)
		{
			yeni->Next = Head;
			Head->Back = yeni;
		}
		else
		{
			yeni->Next=NULL;
		}
		yeni->Back=NULL;
		Head=yeni;
	}
}

Ekle methodu dünki methoda göre biraz değişik gözükmesinin tek nedeni, biraz daha sadeleştirmemden başka birşey değil. Hatta sol'a eklenme durumunda yaptığımız bir önceki vagona ulaşma işlemine bu sefer gerek duymadığımız için bu kısımda kodun kısaldığını söylemek doğru olacaktır.

Methodumuzu tekrar edecek olursak, Öncelikle başa ya da sona ve araya eklenme üzere 2 ana kola ayrılan methodumuzda sol tarafa eklenme için yukarıda dediğimiz gibi artık bir döngü ihtiyacı duymadan Back özelliğimiz ile bir önceki vagona ulaşıp bunu ekleyeceğimizden sonra gelen vagon ile değiştiriyoruz. Geriye kalan kodlarımızda ise herhangi bir değişiklik olmayacak.

Sağa,en başa ve en sona eklenme ise yine aynı şekilde yapılacak.
Sonuç itibariyle Doubly yapısının her iki yöndede hareket edebilme yetisi bizim için işlemleri kısaltarak daha performanslı bir uygulama çıkarmamızı sağlayacaktır. Olumsuz olarak ise her bir kaydın memoryde kapladığı alan yeni gelen bir pointer ile %33 arttı.

Bir sonraki makalemde görüşmek üzere, herkese esenlikler dilerim :)
H.Burak TUNGUT

Ellerine sağlık kardeşim :)
Yorum Bırak

Facebook
Son Yorumlar