C# Yığın/Yığıt (Stack) Kullanımı

Merhaba arkadaşlar bugün sizlerle yığın/yığıt konuları anlatamaya çalışacağım.

yığın konusu bilindi üzere günümüzde bir çok işi yaparken aslında çokça bilerek veya bilmeyerek kullandığımız günlük hayatta ekmek sıralarında, markette alışverşi yaparken, kitaplığımızı bir kutu içerisine dizerken vs bir çok yerde kullandığımız yapının adı aslında.

Yığınlar kullanımı ise en çok bilinen yapılar ise FİLO(First in Last out ) yani ilk giren son çıkar yapısı bir diğer yapı ise LİFO(Last in First out) Yani son giren ilk çıkar yapısıdır. Bunu yukarıda bahsettiğimiz gibi hayatımızın birçok alınında görüyoruz kitaplığımızı toplarken ilk koyduğumuz kitabı sonra olarak alırız Yani FİLO örneğine uymaktadır.

Günlük hayatta kullanımı bu şekildeyken bilgisayar ortamında bunu yapılışı iki farklı şekilde gerçekleşmektedir. Bunlar Dizi ve Bağlantılı liste kullanılarak yapılmaktadır.

Bilgisayar ortamında yığınların kullanılırken yardımcı bir kaç eleman kullanılmaktadır. Bunlar ana yığın ve yardımcı yığın elemanları olmak üzere kullanılır.

Ana yığın İşlemleri:

Push(Nesne):Yeni bir nesne eklemek için kullanılır.

pop(): En Son eklenen nesneyi çıkarıp bütün elemanların tekrar döndürülmesi için kullanılır.

Yardımcı Yığın İşlemleri:

Top(): En son eklenen nesneyi çıkarmadan geri döndürmek için kullanılır.

Size(): Depolanan nesne sayısı geri döndürür(yani Dizi Sayısı)

İsEmpty(): Yığında eleman bulunup bulunmadığı bilgisi geri döner.

Örnek Bir Kullanım

Örnek : Yığına ekleme ve çıkarma
İşlem Yığıt (tepe) Çıktı
push(“M”); M
push(“A”); MA
push(“L”); MAL
push(“T”); MALT
pop(); MAL T
push(“E”); MALE T
pop(); MAL TE
push(“P”); MALP TE
pop(); MAL TEP
push(“E”); MALE TEP
pop(); MAL TEPE

Evet Arkadaşlar örneğimizi gördüğümüze göre bunları c# üzerinde kodlaması gerçekleştirelim.

İlk olarak Yığınımıza Belli bir kapasitesini belirtiyoruz. bunu yapmamızı sebebi ise belli bir sınırdan sonra yığınımızın eleman almamasını istediğimiz için ama siz isterseniz buna bağıl liste mantığı ile yaparak belli bir sınır koymaya bilirsiniz.

Ben bu örneğimde dizi olarak kullanacağım için belli bir sınırlama getirmek istedim.

Şimdi ise yığınımızda sürekli olarak True Veya False değerlerimi geri alacağımız dolumu veya boş mu metodları oluşturuyoruz.

int kapasite = 100;     //Maksımum eleman sayısı
        int[] S;
        int p;

        public Yıgın()      //Yapıcı yordam
        {
            int[] S = new int[kapasite];
            p = 0;
        }
        public bool bosmu() //yıgın bossa true Dondurur
        {
            if (p < 1)
                return true;
            else
                return false;
        }
        public bool dolumu()    //Yığının üstünde yine bir eleman koy  //Başarılı ise 0 başarısız ise -1 döndürür
        {
            if (p == kapasite - 1)
                return true;
            else
                return false;
        }

oluşturduğumuz bu yapılar ile geri dönüş değerlerine göre dizimiz yani yığınımız üzerinde işlemler gerçekleştireceğiz.

Daha sonra ise yeni elemanları koymak için yani push() işlemini gerçekleştirmek için koy() adında bir metot tanımlaması yapıyoruz. metodumuz ilk olarak yığının boş olup olmadıgını kontrol ediyor eğer dolu ise yeni olarak parametre olarak aldığı değeri yazamıyor.

Eğer boş ise yeni değeri yığına ekleme işlemini gerçekleştiriyor.

public int koy(int yeni)    //Yıgının üszerine bir eleman koymak için oluşturulmuş bir metot
        {
            if(dolumu())
            {
                //yığın dolu ise , bir eleman eklemez
                return -1;
            }
            S[p] = yeni;
            p++;
            return 0;
        }

bize en üsteki elemanı geri döndürmesi için ise bir ust() metodu tanımlıyoruz. İşlem sırasında eğer yığın boş ise hata kodu olarak Stack underflow Döndürme işlemini gerçekleştiriyor.

public int ust()
        {
            if(dolumu())
            {
                //yıgın bossa hata dondür.
                Console.WriteLine("Stack Underflov");
                return -1;
            }
            return S[p - 1];
        }

ve en üsteki değeri alıp geri döndürerek metod ise al() ismindeki metodumuz bu bize yığının en üstende ki elemanı geri döndürmemize olanak sağlar.

public int al()
        {
            if(bosmu())
            {
                //yıgın bossa hata dönder
                Console.WriteLine("Stack underflow");
                return -1;
            }
            int id = p - 1; //En üsteki elemanı döndürü
            p--;        //Elemanı sil
            return S[id];
        }

Evet Arkadaşlar son olarak yığınımızı test edeceğimiz metodu yazacak olursak

static void Main(string[] args)
        {
            Yıgın y = new Yıgın();
            if (y.bosmu())
                Console.WriteLine("Yıgın Boş");
            y.koy(49);
            y.koy(23);
            y.koy(36);
            y.koy(34);
            Console.WriteLine("Yıgının ilk elemanı :" + y.al());
            y.koy(44);
            y.koy(22);
            Console.WriteLine("Yıgının ilk elemanı:" + y.al());
            Console.WriteLine("Yıgının ilk elemanı:" + y.al());
            Console.WriteLine("Yıgının ilk elemanı:" + y.ust());
            Console.WriteLine("Yıgının ilk elemanı:" + y.al());
            if (y.bosmu())
                Console.WriteLine("Yıgın Boş");
        }

İlk olarak yığınımızı kontrol ediyoruz daha sonra ise sıra ile 49 , 23 ,36,34 Sayılarını yığınımızı ekliyoruz ve bunu ekrana yazdırıyoruz.

tekrardan 44 ,22 sayılarını yığınımızı ekliyoruz.

ve ekrana ilk olarak 36 sayısını bastıracak daha sonra ise 44 ve 22 sayılarını eklediğimiz için en başta 22 sayısı olacak tekrardan al() metodunu iki defa kullandığımızda 22 ve 44 sayılarını ekrana basacaktır.

Evet Arkadaşlar bu içeriğinde sonuna geldik

Sabırla ve saygıyla okuduğunuz için teşekkür ederim umarım faydalı bir içerik olmuştur.

Bu gibi içerikleri kendi web sayfamda da paylaşıyorum isterseniz orada da beni takip edebilirsiniz

linki Şuraya Bırakıyorum . Teşekkürler.