what is heap data structure java
Bu eğitim, Java Yığın Veri Yapısının ne olduğunu ve Min Heap, Max Heap, Heap Sort, Stack vs Heap gibi kavramları örneklerle açıklar:
Yığın, Java'da özel bir veri yapısıdır. Yığın, ağaç tabanlı bir veri yapısıdır ve tam bir ikili ağaç olarak sınıflandırılabilir. Yığının tüm düğümleri belirli bir sıraya göre düzenlenmiştir.
=> Java Eğitim Serisini Herkes İçin Görmek İçin Burayı Ziyaret Edin
Ne öğreneceksin:
Java'da Yığın Veri Yapısı
Yığın veri yapısında, kök düğüm alt öğeleri ile karşılaştırılır ve sıraya göre düzenlenir. Dolayısıyla, a bir kök düğümse ve b onun alt düğümüyse, özellik, anahtar (a)> = anahtar (b) maksimum bir yığın oluşturacaktır.
Kök ve alt düğüm arasındaki yukarıdaki ilişkiye 'Yığın Özelliği' denir.
Üst-alt düğümlerin sırasına bağlı olarak, yığın genellikle iki türdendir:
# 1) Maksimum Yığın :Bir Maks-Yığın'da kök düğüm anahtarı, yığın içindeki tüm anahtarların en büyüğüdür. Aynı özelliğin, öbekteki tüm alt ağaçlar için yinelemeli olarak doğru olması sağlanmalıdır.
Aşağıdaki diyagram bir Örnek Maks Yığını göstermektedir. Kök düğümün, alt düğümlerinden daha büyük olduğuna dikkat edin.
# 2) Min-Yığın :Bir Min-Heap durumunda, kök düğüm anahtarı, yığın içinde bulunan diğer tüm anahtarlar arasında en küçük veya minimum olanıdır. Max yığınında olduğu gibi, bu özellik, öbekteki diğer tüm alt ağaçlarda yinelemeli olarak doğru olmalıdır.
Bir örnek, Min-yığın ağacının, aşağıda gösterilmiştir. Gördüğümüz gibi, kök anahtar, yığın içindeki diğer tüm anahtarların en küçüğüdür.
Aşağıdaki alanlarda bir yığın veri yapısı kullanılabilir:
- Yığınlar çoğunlukla Öncelik Sıralarını uygulamak için kullanılır.
- Özellikle min-heap, bir Grafikteki köşeler arasındaki en kısa yolları belirlemek için kullanılabilir.
Daha önce belirtildiği gibi, yığın veri yapısı, kök ve alt öğeler için heap özelliğini karşılayan tam bir ikili ağaçtır. Bu yığın aynı zamanda ikili yığın .
İkili Yığın
İkili bir yığın aşağıdaki özellikleri yerine getirir:
- İkili yığın, tam bir ikili ağaçtır. Tam bir ikili ağaçta, son seviye dışındaki tüm seviyeler tamamen doldurulur. Son seviyede, tuşlar olabildiğince soldadır.
- Yığın özelliğini karşılar. İkili yığın, karşıladığı yığın özelliğine bağlı olarak maksimum veya minimum yığın olabilir.
Bir ikili yığın normalde bir Dizi olarak temsil edilir. Tam bir ikili ağaç olduğu için bir dizi olarak kolayca temsil edilebilir. Bu nedenle, ikili yığının bir dizi gösteriminde, kök eleman A (0) olacaktır, burada A, ikili öbeği temsil etmek için kullanılan dizidir.
Yani genel olarak herhangi bir i içininciİkili yığın dizisi gösterimindeki düğüm, A (i), aşağıda gösterildiği gibi diğer düğümlerin indislerini temsil edebiliriz.
| Bir ((i-1) / 2) | Ana düğümü temsil eder |
|---|---|
| Erişim daha hızlıdır. | Yığından daha yavaş. |
| Bir ((2 * i) +1) | Sol alt düğümü temsil eder |
| Bir ((2 * i) +2) | Doğru çocuk düğümü temsil eder |
Aşağıdaki ikili yığını düşünün:
Yukarıdaki min ikili yığının dizi gösterimi aşağıdaki gibidir:
Yukarıda gösterildiği gibi, yığın, seviye sırası yani elemanlar her seviyede soldan sağa aktarılır. Bir seviyedeki unsurlar tükendiğinde, bir sonraki seviyeye geçiyoruz.
Sonra, ikili yığını Java'da uygulayacağız.
Aşağıdaki program Java'daki ikili yığını göstermektedir.
import java.util.*; class BinaryHeap { private static final int d= 2; private int() heap; private int heapSize; //BinaryHeap constructor with default size public BinaryHeap(int capacity){ heapSize = 0; heap = new int( capacity+1); Arrays.fill(heap, -1); } //is heap empty? public boolean isEmpty(){ return heapSize==0; } //is heap full? public boolean isFull(){ return heapSize == heap.length; } //return parent private int parent(int i){ return (i-1)/d; } //return kth child private int kthChild(int i,int k){ return d*i +k; } //insert new element into the heap public void insert(int x){ if(isFull()) throw new NoSuchElementException('Heap is full, No space to insert new element'); heap(heapSize++) = x; heapifyUp(heapSize-1); } //delete an element from the heap at given position public int delete(int x){ if(isEmpty()) throw new NoSuchElementException('Heap is empty, No element to delete'); int key = heap(x); heap(x) = heap(heapSize -1); heapSize--; heapifyDown(x); return key; } //maintain heap property during insertion private void heapifyUp(int i) { int temp = heap(i); while(i>0 && temp > heap(parent(i))){ heap(i) = heap(parent(i)); i = parent(i); } heap(i) = temp; } //maintain heap property during deletion private void heapifyDown(int i){ int child; int temp = heap(i); while(kthChild(i, 1) heap(rightChild)?leftChild:rightChild; } //print the heap public void printHeap() { System.out.print('nHeap = '); for (int i = 0; i Çıktı:
nHeap = 7 4 6 1 3 2 5
Java'da Min Yığın
Java'daki bir min-yığın, tam bir ikili ağaçtır. Min-heap'de kök düğüm, öbekteki diğer tüm düğümlerden daha küçüktür. Genel olarak, her bir iç düğümün anahtar değeri, alt düğümlerinden daha küçük veya ona eşittir.
Min-yığının dizi gösterimi söz konusu olduğunda, eğer bir düğüm 'i' konumunda saklanıyorsa, sol alt düğümü 2i + 1 konumunda depolanır ve sonra sağ alt düğüm 2i + 2 konumunda olur. Konum (i-1) / 2, üst düğümünü döndürür.
Aşağıda, min-heap tarafından desteklenen çeşitli işlemler listelenmiştir.
# 1) Ekle (): Başlangıçta ağacın sonuna yeni bir anahtar eklenir. Anahtar, üst düğümünden daha büyükse, heap özelliği korunur. Aksi takdirde, heap özelliğini tamamlamak için anahtarı yukarı doğru hareket ettirmemiz gerekir. Min yığın halinde ekleme işlemi O (log n) süresini alır.
# 2) extractMin (): Bu işlem, minimum öğeyi yığından kaldırır. Yığın özelliğinin kök eleman (min eleman) öbekten kaldırıldıktan sonra korunması gerektiğini unutmayın. Bu işlemin tamamı O (Logn) alır.
#3) getMin (): getMin (), aynı zamanda minimum öğe olan yığının kökünü döndürür. Bu işlem O (1) saatinde yapılır.
Aşağıda bir Min-yığın için örnek bir ağaç verilmiştir.
Yukarıdaki diyagram bir min-yığın ağacını göstermektedir. Ağacın kökünün ağaçtaki minimum öğe olduğunu görüyoruz. Kök 0 konumunda olduğundan, sol çocuğu 2 * 0 + 1 = 1 ve sağ çocuk 2 * 0 + 2 = 2 konumuna yerleştirilir.
Min Yığın Algoritması
Aşağıda bir min-yığın oluşturmak için kullanılan algoritma verilmiştir.
procedure build_minheap Array Arr: of size N => array of elements { repeat for (i = N/2 ; i >= 1 ; i--) call procedure min_heapify (A, i); } procedure min_heapify (var A( ) , var i, var N) { var left = 2*i; var right = 2*i+1; var smallest; if(left <= N and A(left) < A( i ) ) smallest = left; else smallest = i; if(right <= N and A(right) < A(smallest) ) smallest = right; if(smallest != i) { swap A( i ) and A( smallest )); call min_heapify (A, smallest,N); } }Java'da Min Yığın Uygulaması
Min-heap'i dizi veya öncelik kuyruklarını kullanarak gerçekleştirebiliriz. Öncelik kuyruğu min-heap olarak uygulandığından, min-heap'i öncelik sıralarını kullanarak uygulamak, varsayılan uygulamadır.
Aşağıdaki Java programı, Min-heap'i Dizileri kullanarak gerçekleştirir. Burada, öbek için dizi gösterimini kullanıyoruz ve sonra öbeğe eklenen her öğenin öbek özelliğini korumak için öbeklendirme işlevini uyguluyoruz. Son olarak, yığını görüntülüyoruz.
class Min_Heap { private int() HeapArray; private int size; private int maxsize; private static final int FRONT = 1; //constructor to initialize the HeapArray public Min_Heap(int maxsize) { this.maxsize = maxsize; this.size = 0; HeapArray = new int(this.maxsize + 1); HeapArray(0) = Integer.MIN_VALUE; } // returns parent position for the node private int parent(int pos) { return pos / 2; } // returns the position of left child private int leftChild(int pos) { return (2 * pos); } // returns the position of right child private int rightChild(int pos) { return (2 * pos) + 1; } // checks if the node is a leaf node private boolean isLeaf(int pos) { if (pos >= (size / 2) && pos HeapArray(leftChild(pos)) || HeapArray(pos) > HeapArray(rightChild(pos))) { // swap with left child and then heapify the left child if (HeapArray(leftChild(pos)) = maxsize) { return; } HeapArray(++size) = element; int current = size; while (HeapArray(current) = 1; pos--) { minHeapify(pos); } } // remove and return the heap elment public int remove() { int popped = HeapArray(FRONT); HeapArray(FRONT) = HeapArray(size--); minHeapify(FRONT); return popped; } } class Main{ public static void main(String() arg) { //construct a min heap from given data System.out.println('The Min Heap is '); Min_Heap minHeap = new Min_Heap(7); minHeap.insert(12); minHeap.insert(15); minHeap.insert(30); minHeap.insert(40); minHeap.insert(50); minHeap.insert(90); minHeap.insert(45); minHeap.minHeap(); //display the min heap contents minHeap.display(); //display root node of the min heap System.out.println('The Min val(root node):' + minHeap.remove()); } } Çıktı:
Java'da Maksimum Yığın
Maksimum yığın aynı zamanda tam bir ikili ağaçtır. Bir maksimum yığında, kök düğüm, alt düğümlerden büyüktür veya bunlara eşittir. Genel olarak, maksimum yığın içindeki herhangi bir dahili düğümün değeri, alt düğümlerine eşit veya ondan büyüktür.
Maksimum yığın bir diziye eşlenirken, herhangi bir düğüm 'i' konumunda saklanırsa, sol çocuğu 2i + 1'de ve sağ çocuk 2i + 2'de saklanır.
Tipik Max-heap aşağıda gösterildiği gibi görünecektir:
Yukarıdaki diyagramda, kök düğümün öbek içindeki en büyük düğüm olduğunu ve alt düğümlerinin kök düğümden daha küçük değerlere sahip olduğunu görüyoruz.
Min-heap'e benzer şekilde, maksimum yığın bir dizi olarak da temsil edilebilir.
Öyleyse, eğer A Max heap'i temsil eden bir diziyse, o zaman A (0) kök düğümdür. Benzer şekilde, eğer A (i) maksimum yığın içindeki herhangi bir düğüm ise, o zaman bir dizi kullanılarak temsil edilebilen diğer bitişik düğümler aşağıdadır.
- A ((i-1) / 2), A (i) 'nin ebeveyn düğümünü temsil eder.
- A ((2i +1)), A (i) 'nin sol alt düğümünü temsil eder.
- A (2i + 2), A (i) 'nin sağ alt düğümünü döndürür.
Max Heap üzerinde yapılabilecek işlemler aşağıda verilmiştir.
# 1) Ekle: Ekleme işlemi, maksimum yığın ağacına yeni bir değer ekler. Ağacın sonuna yerleştirilir. Yeni anahtar (değer) üst düğümünden daha küçükse, heap özelliği korunur. Aksi takdirde, yığın özelliğini korumak için ağacın yığınlanması gerekir.
yazılım testi mülakat soruları ve cevapları belgesi
Ekleme işleminin zaman karmaşıklığı O (log n) 'dir.
# 2) ExtractMax: ExtractMax işlemi, maksimum öğeyi (kök) maksimum yığından kaldırır. İşlem ayrıca, heap özelliğini korumak için en fazla öbeği yığınlar. Bu işlemin zaman karmaşıklığı O (log n) 'dir.
# 3) getMax: getMax işlemi, O (1) zaman karmaşıklığı ile maksimum yığının kök düğümünü döndürür.
Aşağıdaki Java programı maksimum yığını uygular. Max heap elemanlarını temsil etmek için burada ArrayList'i kullanıyoruz.
import java.util.ArrayList; class Heap { void heapify(ArrayList hT, int i) { int size = hT.size(); int largest = i; int l = 2 * i + 1; int r = 2 * i + 2; if (l hT.get(largest)) largest = l; if (r hT.get(largest)) largest = r; if (largest != i) { int temp = hT.get(largest); hT.set(largest, hT.get(i)); hT.set(i, temp); heapify(hT, largest); } } void insert(ArrayList hT, int newNum) { int size = hT.size(); if (size == 0) { hT.add(newNum); } else { hT.add(newNum); for (int i = size / 2 - 1; i >= 0; i--) { heapify(hT, i); } } } void deleteNode(ArrayList hT, int num) { int size = hT.size(); int i; for (i = 0; i = 0; j--) { heapify(hT, j); } } void printArray(ArrayList array, int size) { for (Integer i : array) { System.out.print(i + ' '); } System.out.println(); } } class Main{ public static void main(String args()) { ArrayList array = new ArrayList(); int size = array.size(); Heap h = new Heap(); h.insert(array, 3); h.insert(array, 4); h.insert(array, 9); h.insert(array, 5); h.insert(array, 2); System.out.println('Max-Heap array: '); h.printArray(array, size); h.deleteNode(array, 4); System.out.println('After deleting an element: '); h.printArray(array, size); } } Çıktı:
Java'da Öncelik Sırası Min Yığın
Java'daki öncelikli kuyruk veri yapısı, min-heap'i temsil etmek için doğrudan kullanılabilir. Varsayılan olarak, öncelik kuyruğu min-heap uygular.
Aşağıdaki program, Priority Queue kullanarak Java'daki min-heap'i göstermektedir.
import java.util.*; class Main { public static void main(String args()) { // Create priority queue object PriorityQueue pQueue_heap = new PriorityQueue(); // Add elements to the pQueue_heap using add() pQueue_heap.add(100); pQueue_heap.add(30); pQueue_heap.add(20); pQueue_heap.add(40); // Print the head (root node of min heap) using peek method System.out.println('Head (root node of min heap):' + pQueue_heap.peek()); // Print min heap represented using PriorityQueue System.out.println('
Min heap as a PriorityQueue:'); Iterator iter = pQueue_heap.iterator(); while (iter.hasNext()) System.out.print(iter.next() + ' '); // remove head (root of min heap) using poll method pQueue_heap.poll(); System.out.println('
Min heap after removing root node:'); //print the min heap again Iterator iter2 = pQueue_heap.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); } } Çıktı:
Java'da Öncelik Sırası Maksimum Yığın
Öncelik kuyruğunu kullanarak Java'da maksimum yığını temsil etmek için, en küçük yığını ters çevirmek için Collections.reverseOrder'ı kullanmalıyız. Öncelik kuyruğu doğrudan Java'da bir min-yığını temsil eder.
Aşağıdaki programda bir Öncelik kuyruğu kullanarak Max Heap'i uyguladık.
import java.util.*; class Main { public static void main(String args()) { // Create empty priority queue //with Collections.reverseOrder to represent max heap PriorityQueue pQueue_heap = new PriorityQueue(Collections.reverseOrder()); // Add items to the pQueue using add() pQueue_heap.add(10); pQueue_heap.add(90); pQueue_heap.add(20); pQueue_heap.add(40); // Printing all elements of max heap System.out.println('The max heap represented as PriorityQueue:'); Iterator iter = pQueue_heap.iterator(); while (iter.hasNext()) System.out.print(iter.next() + ' '); // Print the highest priority element (root of max heap) System.out.println('
Head value (root node of max heap):' + pQueue_heap.peek()); // remove head (root node of max heap) with poll method pQueue_heap.poll(); //print the max heap again System.out.println('
Max heap after removing root: '); Iterator iter2 = pQueue_heap.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); } } Çıktı:
Java'da Yığın Sıralama
Yığın sıralama, her yineleme için dizide maksimum bir öğe seçtiğimiz, seçim sıralamasına benzer bir karşılaştırmalı sıralama tekniğidir. Yığın sıralama, Yığın veri yapısını kullanır ve sıralanacak dizi öğelerinden minimum veya maksimum yığın oluşturarak öğeleri sıralar.
Min ve maks yığın olarak, kök düğümün sırasıyla dizinin minimum ve maksimum elemanını içerdiğini tartışmıştık. Yığın sıralamada, yığının kök öğesi (minimum veya maksimum) kaldırılır ve sıralanan diziye taşınır. Kalan yığın daha sonra yığın özelliğini korumak için yığınlanır.
Öyleyse, verilen diziyi öbek sıralaması kullanarak sıralamak için özyinelemeli iki adım gerçekleştirmeliyiz.
- Verilen diziden bir yığın oluşturun.
- Kök öğeyi art arda öbekten kaldırın ve sıralı diziye taşıyın. Kalan yığını yığın haline getirin.
Yığın sıralamanın Zaman Karmaşıklığı tüm durumlarda O (n log n) 'dir. Uzay karmaşıklığı O (1) 'dir.
Java'da Yığın Sıralama Algoritması
Aşağıda verilen diziyi artan ve azalan düzende sıralamak için yığın sıralama algoritmaları verilmiştir.
# 1) Artan düzende sıralamak için Yığın Sıralama algoritması:
- Verilen dizi için sıralanacak maksimum bir yığın oluşturun.
- Kökü silin (giriş dizisindeki maksimum değer) ve onu sıralanmış diziye taşıyın. Dizideki son öğeyi köke yerleştirin.
- Yığının yeni kökünü yığın haline getirin.
- Tüm dizi sıralanana kadar 1. ve 2. adımları tekrarlayın.
# 2) Azalan sırada sıralamak için Yığın Sıralama algoritması:
- Verilen dizi için min. Yığın oluşturun.
- Kökü (dizideki minimum değer) kaldırın ve dizideki son elemanla değiştirin.
- Yığının yeni kökünü yığın haline getirin.
- Tüm dizi sıralanana kadar 1. ve 2. adımları tekrarlayın.
Java'da Yığın Sıralama Uygulaması
Aşağıdaki Java programı, bir diziyi artan sırada sıralamak için yığın sıralamayı kullanır. Bunun için, önce bir maks. Yığın oluşturuyoruz ve ardından yukarıdaki algoritmada belirtildiği gibi kök öğeyi yinelemeli olarak değiştirip yığınlıyoruz.
import java.util.*; class HeapSort{ public void heap_sort(int heap_Array()) { int heap_len = heap_Array.length; // construct max heap for (int i = heap_len / 2 - 1; i >= 0; i--) { heapify(heap_Array, heap_len, i); } // Heap sort for (int i = heap_len - 1; i >= 0; i--) { int temp = heap_Array(0); heap_Array(0) = heap_Array(i); heap_Array(i) = temp; // Heapify root element heapify(heap_Array, i, 0); } } void heapify(int heap_Array(), int n, int i) { // find largest value int largest = i; int left = 2 * i + 1; int right = 2 * i + 2; if (left heap_Array(largest)) largest = left; if (right heap_Array(largest)) largest = right; // recursively heapify and swap if root is not the largest if (largest != i) { int swap = heap_Array(i); heap_Array(i) = heap_Array(largest); heap_Array(largest) = swap; heapify(heap_Array, n, largest); } } } class Main{ public static void main(String args()) { //define input array and print it int heap_Array() = {6,2,9,4,10,15,1,13}; System.out.println('Input Array:' + Arrays.toString(heap_Array)); //call HeapSort method for given array HeapSort hs = new HeapSort(); hs.heap_sort(heap_Array); //print the sorted array System.out.println('Sorted Array:' + Arrays.toString(heap_Array)); } } Çıktı:
Yığın sıralama tekniğinin genel zaman karmaşıklığı O (nlogn) 'dur. Yığınlama tekniğinin zaman karmaşıklığı O (logn). Yığın oluşturmanın zaman karmaşıklığı O (n) iken.
Java'da Stack Vs Heap
Şimdi bir Yığın veri yapısı ile yığın arasındaki bazı farkları tablo halinde sıralayalım.
Yığın Yığın Yığın, doğrusal bir veri yapısıdır. Yığın, hiyerarşik bir veri yapısıdır. LIFO (Son Giren, İlk Çıkar) sırasını takip eder. Geçiş, seviye sırasına göre yapılır. Çoğunlukla statik bellek tahsisi için kullanılır. Dinamik bellek tahsisi için kullanılır. Bellek bitişik olarak tahsis edilir. Bellek rastgele konumlara tahsis edilir. Yığın boyutu İşletim sistemine göre sınırlıdır. İşletim sistemi tarafından uygulanan yığın boyutu sınırı yoktur. Yığın yalnızca yerel değişkenlere erişebilir. Heap, kendisine tahsis edilmiş global değişkenlere sahiptir. Belleğin tahsisi / serbest bırakılması otomatiktir. Tahsis etme / tahsisi kaldırma, programcı tarafından manuel olarak yapılmalıdır. Yığın, Diziler, Bağlantılı Liste, DiziListesi, vb. Veya diğer doğrusal veri yapıları kullanılarak uygulanabilir. Yığın, Diziler veya ağaçlar kullanılarak gerçekleştirilir. Daha azsa bakım maliyeti. Bakımı daha maliyetli. Hafıza sınırlı olduğundan hafıza yetersizliğine neden olabilir. Hafıza sıkıntısı yok ama hafıza parçalanmasından muzdarip olabilir.
Sıkça Sorulan Sorular
S # 1) Stack, Heap'ten daha mı hızlı?
Cevap: Erişim, yığınla karşılaştırıldığında yığın içinde doğrusal olduğundan, yığın yığından daha hızlıdır.
S # 2) Yığın ne için kullanılır?
Cevap: Yığın çoğunlukla Dijkstra'nın algoritması gibi iki nokta arasındaki minimum veya en kısa yolu bulan algoritmalarda, yığın sıralaması kullanarak sıralama, öncelikli kuyruk uygulamaları (min-heap) vb. İçin kullanılır.
S # 3) Yığın nedir? Türleri nelerdir?
Cevap: Yığın, hiyerarşik, ağaç tabanlı bir veri yapısıdır. Yığın, tam bir ikili ağaçtır. Yığınlar iki türdendir, yani, kök düğümün tüm düğümler arasında en büyüğü olduğu Maks yığın; Kök düğümün tüm anahtarlar arasında en küçük veya minimum olduğu minimum yığın.
S # 4) Yığının bir yığına göre avantajları nelerdir?
Cevap: Yığın yığınına göre en büyük avantajı yığın içindedir, bellek dinamik olarak tahsis edilir ve bu nedenle ne kadar bellek kullanılabileceği konusunda bir sınır yoktur. İkinci olarak, yığına yalnızca yerel değişkenler tahsis edilebilirken, aynı zamanda yığın üzerinde global değişkenler de tahsis edebiliriz.
S # 5) Heap'in kopyaları olabilir mi?
Cevap: Evet, yığın tam bir ikili ağaç olduğundan ve ikili arama ağacının özelliklerini karşılamadığından öbek içinde yinelenen anahtarlara sahip düğümlere sahip olma konusunda herhangi bir kısıtlama yoktur.
Sonuç
Bu eğitimde, yığın türlerini kullanarak yığın ve yığın sıralama türlerini tartıştık. Ayrıca türlerinin Java'daki ayrıntılı uygulamasını da gördük.
=> Mükemmel Java Eğitim Kılavuzuna Buradan Bakabilirsiniz.
Önerilen Kaynaklar
- Java Grafik Eğitimi - Grafik Veri Yapısı Nasıl Uygulanır
- C ++ 'da Veri Yapılarına Giriş
- Örneklerle C ++ 'da Yığın Sıralama
- C ++ 'da AVL Ağacı ve Yığın Veri Yapısı
- C ++ 'da İkili Ağaç Veri Yapısı
- Çizim ile C ++ 'da Kuyruk Veri Yapısı
- Çizim ile C ++ 'da Dairesel Bağlantılı Liste Veri Yapısı
- Java Temelleri: Java Sözdizimi, Java Sınıfı ve Temel Java Kavramları
