Listeler erik Soyut Veri Yaps Abstract Data Type

Listeler

İçerik * Soyut Veri Yapısı - Abstract Data Type (ADT) * Liste SVY nın Dizi ile gerçekleştirilmesi * Bağlantılı Listeler * Temel İşlemler n Ekleme - Insert, Bul- find, sil-delete, yaz-print, etc. * Bağlantılı liste türevleri Dairesel (Circular) bağlantılı listeler n Çift-yönlü (Doubly) bağlantılı listeler n

Soyut Veri Yapısı * Veri tipi Nesneler kümesi + işlemler kümesi n Örnek : integer n 1 Tamsayılar kümesi 1 işlemler: +, -, x, / * Genelleştirilebilinir mi? (örnek prosedürler bir işlem kavramını genelleştirir) n Evet! n Ø Soyut veri tipi Yüksek-seviyede soyutlama high-level abstractions (soyutlama aracılığıyla karmaşıklık kontrolü) n Kaysülleme (Encapsulation) / giydirme n

Kapsülleme SVT üzerindeki işlemler sadece uygun fonksiyonun çağrılması ile yapılabilir. Ø Tip tanımı ve bu tip üzerindeki işlemler, programın bir bölümüne yerleştirilebilinir. Ø Eğer SVT nin gerçekleştirilmesi değiştirmek isteniyorsa n Nereye bakacağımızı biliyoruz. n Bir kısmını değiştirmekle programın başka yerlerinde hata çıkmayacağından emin oluruz. ü SVT basit tipler gibi davranabiliriz: Alt plandaki gerçekleştirilmesiyle ilgilenmemize gerek kalmayabilir. * SVT C++: class * metot C++: member function üye fonksiyonu *

SVT… * Örnekler n set – küme SVT 1 Elemanların kümesi 1 işlemler: birleşim- union, kesişim-intersection, boyutusize and tersi-complement n queue – kuyruk SVT 1 Elemanların art arda dizilmiş hali 1 işlemler: boş kuyruk oluştur-create empty queue, ekleinsert, incele-examine, sil-delete, ve yoket-destroy * İki SVT aynı değildir: Alt planda aynı modele sahip olmasına rağmen işlemleri farklıysa. n Örnek. Sadece birleşim ve bul işlemleri içeren setküme SVT farklıdır. n Gerçekleştirmenin uygunluyu çalıştırılan işlemlere çok bağlıdır.

Avantaj ve Dezavantajları ü ü SVTlerinin kullanımı, gerçekleştirmesinden ayrıdır/ ayrılır. Modülerdir: bir SVT için bir modül Hata ayıklaması (debug) kolaydır. n Birden fazla kişinin aynı anda beraber çalışmasına uygundur. n ü ü SVT kodu farklı uygulamalar için tekrar kullanılabilir. Bilgi gizleme Belirli bir işi yapmak için tasarlanmış mantıksal birimdir. n Kullanıcı programlarını etkilemeden gerçekleştirme detayları değiştirilebilir. n ü Hızlı prototiplemeye müsaittir. n O Basit SVT gerçekleştirmeleri ile prototipini yap ve sonra gerekirse ayarlama yap. Verimlilik kaybı

Liste SVT * Sıfır veya birden fazla elemanların art arda dizilmiş hali A 1, A 2, A 3, … A N * N: liste uzunluğu * A 1: ilk eleman * AN: son eleman * Ai: i. Eleman / pozisyon * If N=0, then listeyi boşalt * Lineer olarak sıralanmış Ai precedes (önce gelir) Ai+1 n A follows (takip eder) A n

İşlemler * print. List: listeyi yaz * make. Empty: boş liste oluştur * find: listedeki bir elemanın pozisyonunu bul liste: 34, 12, 52, 16, 12 n find(52) 3 n * insert: n listeye bir eleman ekle insert(x, 3) 34, 12, 52, x, 16, 12 * remove: n listeden bir eleman sil remove(52) 34, 12, x, 16, 12 * find. Kth: Belirli bir pozisyondaki elemanı getir.

SVT Gerçekleştirmesi * SVT n ini ifade edecek bir veri yapısı seç Örnek: Diziler, kayıtlar vb. * Each operation associated with the ADT is implemented by one or more subroutines * Two standard implementations for the list ADT Array-based n Linked list n

Dizi Gerçekleştirmesi * Elemanlar art arda bir şekilde kaydediliyor.

Dizi Gerçekleştirmesi. . . * Listenin maksimum boyutunun bilinmesini gerektirir Ø Yer israfı * print. List doğrusal * find. Kth: sabit * insert ve delete: yavaş n ve find: örnek 0. pozisyona ekleme (yeni eleman) 1Öncelikle yer açmak için bütün dizinin bir hücre kaydırılmasını gerektirir. n örnek 0. pozisyonda silme 1 Bütün n elemanların bir hücre yukarı kaydırılması gerekir Ortalama olarak her iki işlemde de listenin yarısının yer değiştirmesi gerekir.

İşaretçi Gerçekleştirmesi (Bağlantılı Liste) * Liste de elemanlar art arda depolanmayacaksa bağlantılı liste kullanılabilir n Hafızada art arda olmasına gerek olmayan yapılardır. n § Her düğüm bir eleman ve kendisinden sonra gelen düğümüm adresini içeren bir işaretçi barındırır. §Son hücre bir sonraki bağlantı olarak NULL değerini gösterir. § Dizi gerçekleştirmesi ile karşılaştırılırsa, üİşaretçi uygulaması gerektiği kadar alan kullanır ûFakat herbir hücrede işaretçi için alan tutar.

Bağlantılı Listeler A B C Baş Bağlanmış düğümler serisine bağlantılı liste denir * Her düğüm en az aşağıdakileri içerir. * Veri (herhangi bir tiple olabilir) n Listedeki bir sonraki düğüme olan işaretçi n Baş: İlk düğüme olan işaretçidir * Son düşüm NULL’ a işaret edernode * A veri işaretçi

Basit bir Bağlantılı Liste Sınıfı * İki sınıf kullanılır : Node ve List * Node sınıfını düğümler için tanımla data: double-tipinde veri n next: listedeki bir sonraki düğüme işaretçi n class Node { public: double Node* }; data; next; // data // pointer to next

Basit bir Bağlantılı Liste Sınıfı * List sınıfı aşağıdakiler içerir head: listedeki ilk düğüme olan işaretçi. İlk başta liste boş olduğu için, head, NULL değerini alır. n List üzerindeki işlemler n class List { public: List(void) { head = NULL; } ~List(void); // constructor // destructor bool Is. Empty() { return head == NULL; } Node* Insert. Node(int index, double x); int Find. Node(double x); int Delete. Node(double x); void Display. List(void); private: Node* head; };

Basit bir bağlantılı liste sınıfı * List n n n işlemleri Is. Empty: listenin boş oluş olmadığını belirle. Insert. Node: belirlenen bir pozisyona yenib ir düğüm ekle Find. Node: verilen bir değere sahip düğümü bul Delete. Node: verilen bir değere sahip düğümü sil Display. List: listedeki bütün düğümleri listele

Yeni bir düğüm ekleme * Node* Insert. Node(int index, double x) n index’inci elemandan sonra verisi x’e eşit olan düğümü ekle n Eğer ekleme başarılı ise, eklenmiş düğümü dönder yoksa, return NULL. (örnek. , index = 0 iken, düğümü ilk eleman olarak ekle; index = 1 iken, ilk elemandan sonra düğüm ekle. ) (Eğer index < 0 veya > liste uzunluğu ise , ekleme başarısız olacak. ) * Adımlar n n index’inci elemanı bul Yeni düğüm için hafızada yer ayır Yeni düğüm kendisinden sonrakini gösterecek Yeni düğümden önceki yeni düğümü gösterecek index’inci eleman new. Node

Yeni bir düğüm ekleme * Insert. Node ‘ da karşılan durumlar Boş listeye ekle 2. En öne ekle 3. En sona ekle 4. Ortaya ekle 1. * Gerçekte iki temel durum vardır. İlk düğüm olarak ekleme (Durum 1 and Durum 2) n Ortaya veya sona ekleme (Durum 3 and Durum 4) n

Yeni bir düğüm ekleme Node* List: : Insert. Node(int index, double x) { if (index < 0) return NULL; Try to locate index’th node. If it doesn’t exist, return NULL. int curr. Index = 1; Node* curr. Node = head; while (curr. Node && index > curr. Index) { curr. Node = curr. Node->next; curr. Index++; } if (index > 0 && curr. Node == NULL) return NULL; Node* new. Node = new. Node->data = if (index == 0) { new. Node->next head } else { new. Node->next curr. Node->next } return new. Node; } new x; Node; = = head; new. Node; = = curr. Node->next; new. Node;

Yeni bir düğüm ekleme Node* List: : Insert. Node(int index, double x) { if (index < 0) return NULL; int curr. Index = 1; Node* curr. Node = head; while (curr. Node && index > curr. Index) { curr. Node = curr. Node->next; curr. Index++; } if (index > 0 && curr. Node == NULL) return NULL; Node* new. Node = new. Node->data = if (index == 0) { new. Node->next head } else { new. Node->next curr. Node->next } return new. Node; } new x; Node; = = head; new. Node; = = curr. Node->next; new. Node; Create a new node

Yeni bir düğüm ekleme Node* List: : Insert. Node(int index, double x) { if (index < 0) return NULL; int curr. Index = 1; Node* curr. Node = head; while (curr. Node && index > curr. Index) { curr. Node = curr. Node->next; curr. Index++; } if (index > 0 && curr. Node == NULL) return NULL; Node* new. Node = new. Node->data = if (index == 0) { new. Node->next head } else { new. Node->next curr. Node->next } return new. Node; } new x; Node; = = head; new. Node; = = curr. Node->next; new. Node; Insert as first element head new. Node

Yeni bir düğüm ekleme Node* List: : Insert. Node(int index, double x) { if (index < 0) return NULL; int curr. Index = 1; Node* curr. Node = head; while (curr. Node && index > curr. Index) { curr. Node = curr. Node->next; curr. Index++; } if (index > 0 && curr. Node == NULL) return NULL; Node* new. Node = new. Node->data = if (index == 0) { new. Node->next head } else { new. Node->next curr. Node->next } return new. Node; } new x; Node; = = head; new. Node; Insert after curr. Node = = curr. Node->next; new. Node; new. Node

Bir düğüm bulma * int Find. Node(double x) n Listede verisi x olan düğümü ara. n Eğer böyle bir düğüm varsa pozisyonunu dönder, . Yoksa, return 0. int List: : Find. Node(double x) { Node* curr. Node = head; int curr. Index = 1; while (curr. Node && curr. Node->data != x) { curr. Node = curr. Node->next; curr. Index++; } if (curr. Node) return curr. Index; return 0; }

Düğüm silme * int Delete. Node(double x) n Listeden verisi x from the list. n * Böyle bir düğüm varsa , pozisyonunu dönder. Yoksa, return 0. Adımlar n İstenen düğümü bul (Find. Node işlemine benzer) Bunulan düğümün işgal ettiği hafızayı boşalt (gözden çıkar) n Bulunan düğümün öncekisi, bulunan düğümün sonrakisini gösterir şekilde ayarla. n * Insert. Node, gibi iki özel durum vardır. İlk düğümü sil n Ortadaki veya sonraki düğümü sil. n

Düğüm silme int List: : Delete. Node(double x) { Try to find the node Node* prev. Node = NULL; its value equal to x Node* curr. Node = head; int curr. Index = 1; while (curr. Node && curr. Node->data != x) { prev. Node = curr. Node; curr. Node = curr. Node->next; curr. Index++; } if (curr. Node) { if (prev. Node) { prev. Node->next = curr. Node->next; delete curr. Node; } else { head = curr. Node->next; delete curr. Node; } return curr. Index; } return 0; } with

Düğüm silme int List: : Delete. Node(double x) { Node* prev. Node = NULL; Node* curr. Node = head; int curr. Index = 1; while (curr. Node && curr. Node->data != x) { prev. Node = curr. Node; curr. Node = curr. Node->next; curr. Index++; prev. Node curr. Node } if (curr. Node) { if (prev. Node) { prev. Node->next = curr. Node->next; delete curr. Node; } else { head = curr. Node->next; delete curr. Node; } return curr. Index; } return 0; }

Düğüm silme int List: : Delete. Node(double x) { Node* prev. Node = NULL; Node* curr. Node = head; int curr. Index = 1; while (curr. Node && curr. Node->data != x) { prev. Node = curr. Node; curr. Node = curr. Node->next; curr. Index++; } if (curr. Node) { if (prev. Node) { prev. Node->next = curr. Node->next; delete curr. Node; } else { head = curr. Node->next; delete curr. Node; } return curr. Index; } head curr. Node return 0; }

Bütün elemanları yazdırma * void Display. List(void) Bütün düğümlerin verilerini yazdır n Listedeki düğüm sayısını yazdır. n void List: : Display. List() { int num = 0; Node* curr. Node = head; while (curr. Node != NULL){ cout << curr. Node->data << endl; curr. Node = curr. Node->next; num++; } cout << "Number of nodes in the list: " << num << endl; }

Listeyi yoketme * ~List(void) destructor u kullanarak liste tarafından işgal edilen hafızayı serbest bırak. n Listedeki her bir düğümü birer sil. List: : ~List(void) { Node* curr. Node = head, *next. Node = NULL; while (curr. Node != NULL) { next. Node = curr. Node->next; // destroy the current node delete curr. Node; curr. Node = next. Node; } } n

6 7 5 Number of nodes in the list: 3 5. 0 found 4. 5 not found 6 5 Number of nodes in the list: 2 result List ‘ in kullanımı int main(void) { List list; list. Insert. Node(0, 7. 0); list. Insert. Node(1, 5. 0); list. Insert. Node(-1, 5. 0); list. Insert. Node(0, 6. 0); list. Insert. Node(8, 4. 0); // print all the elements list. Display. List(); if(list. Find. Node(5. 0) > 0) else if(list. Find. Node(4. 5) > 0) else list. Delete. Node(7. 0); list. Display. List(); return 0; } // // // successful unsuccessful cout << << "5. 0 "4. 5 found" << endl; not found" << endl;

Bağlantılı Liste Çeşitleri * Dairesel n (Çevrimsel) bağlantılı listeler Son düğüm listedeki ilk düğümü işaret eder A Head n B C Listeyi gezmeyi ne zaman bitireceğimizi nasıl bileceğiz? (İpucu: current node işaretçisinin kafa (baş) ı işaret edip etmediğini kontrol et. )

Bağlantılı Liste Çeşitleri * Çift bağlantılı liste (Doubly linked lists) Herbir düğüm hem öncekini hem sonrakini işaret eder. n İki NULL vardır: listenin ilk ve son düğümlerinde Avantajı: verilen düğümde, öncekini ziyaret etmek kolaydır. Listeleri ters yönde gezmek kolayıdır. n A Head B C

Dizi ve Bağlantılı Listeler * Bağlantılı listelerin kodlaması ve yönetimi dizilerden daha zordur fakat kendine has avantajları vardır. n Dinamik: bir bağlantılı liste kolaylıkla büyüyebilir ve daralabilir. 1 Listede kaç düğüm olması gerektiğini bilmemize gerek yoktur. Gerektikçe hafızada oluşturulur. 1 Buna karşılık C++ ‘ da dizi boyutu derleme zamanında sabittir. n Kolay ve hızlı ekleme ve silme 1 Dizide ekleme ve silme için geçici değişkenlere kopyalamak ve boşluk açmak veya boşluğu silmek gerekir. 1 Bağlantılı listede ise düğümlerin hareket etmesine gerek yoktur. Sadece işaretçilerin ayarları değiştirilir.

Örnek: Polinomial SVT Tek- değişkenli polinomial için SVT * Dizi gerçekleştirmesi *

Polinomial SVT … Eğer Aj katsayıları sıfırdan farklı ise kabul edilebilirdir, diğer durumda istenmez. n Örnek: Çarp n 1 Zamanın çoğu sıfırların çarpımı için ve var olmayan parçaların çarpımı için harcanır. * Bağlantılı n liste kullanılarak uygulanması Herbir terim bir hücrede tutulur ve üstel değerlerin azalmasına göre sıralanır.