Data StructuresVeri Yapıları

Undergraduate, Giresun University, Computer Engineering, 2026

Lisans, Giresun Üniversitesi, Bilgisayar Mühendisliği, 2026

data structure Veri yapıları, veriyi düzenlemenin, saklamanın ve ona erişmenin sistemli yollarını sunar. Uygun yapıyı seçmek arama, ekleme, silme ve gezinme gibi işlemlerin verimini doğrudan etkiler. Bu ders algoritma analizini, dizileri, özyinelemeyi, bağlı listeleri, listeleri, yığınları, kuyrukları, ağaçları, arama ağaçlarını, öncelikli kuyrukları ve heap’i, hash tablolarını, kümeleri ve ayrık kümeleri ve çizgeleri; gerçeklemelerine, karmaşıklıklarına ve uygulamalarına ağırlık vererek inceler.

Ders Kitabı

📕 Veri Yapıları (PDF, 19 MB)

Başlangıç Kaynakları

Kısım I: Temeller

Bölüm 1: Giriş

Veri yapıları, verinin bellekte nasıl düzenleneceğini ve ona nasıl erişileceğini belirler. Bu bölümde verinin sayısal ortamda nasıl temsil edildiği, Java’daki ilkel ve referans tipler, referans kopyalama ve jenerikler ele alınır. Soyut veri tipi (hangi işlemlerin sunulduğu) ile veri yapısı (bu işlemlerin nasıl gerçeklendiği) arasındaki ayrım bir yığın örneğiyle gösterilir. Bölüm, veri yapısı seçimi ve dersteki temel yapıların kısa bir karşılaştırma tablosuyla kapanır.

Bölüm 2: Algoritma Analizi

Algoritma analizi, çözümleri uygulamadan önce karşılaştırmayı sağlar. Deneysel ölçüm ve katlama deneyi çalışma süresinin pratikte nasıl büyüdüğünü gösterir; ilkel işlemleri saymak ise makineden bağımsız bir ölçü verir. Büyük O, Büyük Omega ve Büyük Teta üst, alt ve sıkı sınırları anlatır; en iyi, ortalama ve en kötü durum ayrı ayrı incelenir. Döngü kalıpları, doğrusal ve ikili arama ile önek ortalamaları kodun yapısının karmaşıklığı nasıl belirlediğini gösterir. Alan karmaşıklığı, doğruluk ve sağlamlık da bu bölümdedir.

Bölüm 3: Diziler

Dizi, öğeleri bellekte ardışık yerleşen en temel veri yapısıdır; her öğeye indisiyle sabit sürede erişilir. Java’da dizi tanımlama, kopyalama, java.util.Arrays ve çok boyutlu diziler; ortalama, ortanca, mod ve tersine çevirme gibi temel dizi algoritmaları; matris işlemleri ve küçük bir XOX oyunu bu bölümde yer alır. Erişimin O(1), araya ekleme ve silmenin ise öğe kaydırma yüzünden O(n) olduğu gösterilir; seçimli ve eklemeli sıralama da dizi üzerinde incelenir.

Bölüm 4: Özyineleme

Özyineleme, bir problemi taban durumuna ulaşana kadar aynı problemin daha küçük örneklerine indirger. Her özyinelemeli çağrı çağrı yığınında kendi çerçevesini alır; bir özyinelemeli metodu izlemek bu çerçevelerin eklenip çıkarılmasını izlemektir. Doğrusal özyineleme (toplam, tersine çevirme, hızlı üs alma), ikili özyineleme (Fibonacci, ikili arama), Hanoi Kuleleri ve geri izleme örnekleri (alt kümeler, permütasyonlar) adım adım incelenir. Yineleme bağıntıları özyinelemeli algoritmaların zaman ve alan maliyetini verir; kuyruk özyinelemesi ve döngüye çevirme ile bölüm tamamlanır.

Kısım II: Doğrusal Yapılar

Bölüm 5: Bağlı Listeler

Bağlı liste, her biri veri ve bir sonraki düğüme referans taşıyan düğümlerden oluşur. Ardışık bellek gerektirmediği için başa ekleme ve silme sabit sürede yapılır; buna karşılık rastgele erişim yoktur ve bir öğeye ulaşmak için baştan gezinmek gerekir. Tek yönlü listede gezinme, ekleme, silme, tersine çevirme, tekrarları kaldırma ve sıralı listeleri birleştirme; çift yönlü listede bekçi düğümler; dairesel listede döngü tespiti ve döndürme bu bölümün konularıdır.

Bölüm 6: Liste ADT ve Java Koleksiyonları

Liste, öğelerin sıralı bir dizisini temsil eden soyut veri tipidir; büyüyüp küçülebilir ve ekleme, silme, erişim ve gezinme işlemlerini destekler. Java’nın koleksiyon hiyerarşisi (Iterable, Collection, List), Iterator ve ListIterator ile gezinme ve gezinirken güvenli silme bu bölümde ele alınır. ArrayList’in dinamik dizi olarak büyümesi ve amortize analizi, LinkedList ile karşılaştırması, konumsal liste ADT’si, Vector, CopyOnWriteArrayList ve Arrays.asList de incelenir.

Bölüm 7: Yığınlar

Yığın, son giren ilk çıkar (LIFO) ilkesiyle çalışır: ekleme (push) ve çıkarma (pop) yalnızca üstten yapılır. Yığın ADT’si, dizi ve bağlı liste ile gerçeklenmesi ve işlemlerin maliyeti ele alınır. Geri/ileri gezinme, çağrı yığını, parantez kontrolü, sonraki büyük öğe, en küçük öğeyi tutan yığın, Hanoi Kulelerinin yığınla çözümü ve stock span problemi yığının uygulamalarıdır. Ara ek (infix), önek (prefix) ve sonek (postfix) gösterimleri arasında dönüşüm ve sonek ifadelerin değerlendirilmesi bölümü tamamlar.

Bölüm 8: Kuyruklar ve Deque

Kuyruk, ilk giren ilk çıkar (FIFO) ilkesiyle çalışır: öğeler bir uçtan eklenir (enqueue), öbür uçtan çıkarılır (dequeue). Basit dizi kuyruğunun sorunu, dairesel kuyruk ve indis formülleri, dolu/boş ayrımı, kuyruğun büyütülmesi ve bağlı liste ile gerçekleme bu bölümdedir. İki uçtan da ekleme ve çıkarmaya izin veren deque, kayan pencere maksimumu gibi problemlerde kullanılır. Round robin çizelgeleme, Josephus problemi, ikilik sayıların üretilmesi ve iki yığınla kuyruk uygulama örnekleridir.

Kısım III: Ağaçlar

Bölüm 9: Ağaçlar

Ağaç, düğümlerin kenarlarla bağlandığı hiyerarşik bir yapıdır: bir kökten başlar, her düğümün tek ebeveyni ve birden çok çocuğu olabilir. Dosya sistemleri, kurum şemaları ve HTML belgeleri ağaçla temsil edilir. Derece, derinlik ve yükseklik gibi temel kavramlar, ikili ağaç türleri (dolu, tam, mükemmel) ve özellikleri, dizi ve bağlı gösterimler incelenir. Kök önde, kök ortada, kök sonda ve düzey sırası gezinmeleri hem özyinelemeli hem yığın ve kuyrukla gerçeklenir; ifade ağaçları ve özyinelemeli ağaç fonksiyonları (boyut, yükseklik, yaprak sayısı) uygulamalardır.

Bölüm 10: Arama Ağaçları

İkili arama ağacında (BST) her düğümün sol alt ağacındaki anahtarlar düğümünkinden küçük, sağ alt ağacındakiler büyüktür. Arama, ekleme ve silme O(h) sürer; h ağacın yüksekliğidir. Dengeli ağaçta bu O(log n) olur, en kötü durumda O(n)’ye düşer. BST’de arama, ekleme, ardıl ve öncül, üç durumlu silme ve aralık sorguları incelendikten sonra yüksekliği sınırlı tutan AVL, kırmızı-siyah ve splay ağaçları ele alınır. Diskteki veriler için B-ağacı ve B+ ağacı gibi çok yollu arama ağaçları düğüm başına çok sayıda anahtar tutarak ağacı sığ tutar.

Bölüm 11: Öncelikli Kuyruklar ve Heap

Öncelikli kuyruk, her seferinde en yüksek (ya da en düşük) öncelikli öğeyi çıkaran soyut veri tipidir. Sırasız ve sıralı listeyle gerçeklemenin maliyetleri karşılaştırıldıktan sonra ikili heap incelenir: max-heap’te her ebeveyn çocuklarından büyük ya da onlara eşittir. Dizi gösterimi, yukarı ve aşağı süzmeyle (up-heap, down-heap) ekleme ve silme, uyarlanabilir öncelikli kuyruk, O(n) sürede heap oluşturma ve heap sort bu bölümdedir. Java’nın PriorityQueue sınıfı, k’ıncı en büyük öğe ve öncelikli çizelgeleyici uygulama örnekleridir.

Kısım IV: Eşlemeler, Kümeler ve Çizgeler

Bölüm 12: Eşlemeler ve Hash Tabloları

Eşleme (map), anahtarları değerlere bağlayan soyut veri tipidir. Hash tablosu, bir hash fonksiyonuyla anahtardan bir kova indisi hesaplar ve iyi dağılan anahtarlarla ekleme, silme ve aramayı ortalamada O(1) sürede yapar; en kötü durumda bu O(n)’ye çıkabilir. İyi bir hash fonksiyonunun özellikleri, Java’daki equals/hashCode sözleşmesi, çakışmaları çözmek için ayrı zincirleme ve açık adresleme (doğrusal yoklama, karesel yoklama, çift hash), yük faktörü ve yeniden boyutlandırma bu bölümün konularıdır. Java HashMap’in iç yapısı ve iki toplam gibi uygulamalarla bölüm tamamlanır.

Bölüm 13: Kümeler ve Ayrık Kümeler

Küme, birbirinden farklı öğelerin sırasız topluluğudur; tekrar eden öğe içermez. Birleşim, kesişim ve fark işlemleri, Java’nın Set arayüzü ve hash tabanlı, ağaç tabanlı ve bit vektörü ile gerçeklemeler karşılaştırılır; çoklu küme ve çoklu eşleme de ele alınır. Ayrık kümeler (union-find) yapısı, boyuta ya da rütbeye göre birleştirme ve yol kısaltmayla bağlantı sorgularını neredeyse sabit amortize sürede yanıtlar; bağlantılı bileşen sayma bunun bir uygulamasıdır.

Bölüm 14: Çizgeler

Çizge, nesneler arasındaki ilişkileri düğümler ve kenarlarla temsil eder. Ağaçlardan farklı olarak döngü ve iki düğüm arasında birden çok yol içerebilir; yönlü ya da yönsüz, ağırlıklı ya da ağırlıksız olabilir. Sosyal ağlar, yol haritaları ve bilgisayar ağları çizgeyle modellenir. Komşuluk matrisi ve komşuluk listesi gösterimleri, genişlik öncelikli (BFS) ve derinlik öncelikli (DFS) arama, bağlantılı bileşenler, iki parçalı çizgeler, topolojik sıralama ve yönlü döngü tespiti incelenir. Ağırlıksız en kısa yol ve Dijkstra algoritmasından sonra minimum kapsayan ağaç problemi ayrık kümelerle Kruskal, öncelikli kuyrukla Prim algoritması üzerinden çözülür.

data structure Data structures provide systematic ways to organize, store, and access data. Choosing an appropriate structure directly affects the efficiency of operations such as searching, insertion, deletion, and traversal. This course examines algorithm analysis, arrays, recursion, linked lists, lists, stacks, queues, trees, search trees, priority queues and heaps, hash tables, sets and disjoint sets, and graphs, with an emphasis on their implementations, complexity, and practical applications.

The course is taught in Turkish: the book, lecture notes, slides, study questions and simulators are in Turkish. This page summarizes them in English.

Textbook

📕 Veri Yapıları — the course book (PDF, in Turkish, 19 MB)

Getting Started

Part I: Foundations

Chapter 1: Introduction

Data structures determine how data is laid out in memory and how it is accessed. This chapter covers how data is represented digitally, Java’s primitive and reference types, reference copying and generics. The distinction between an abstract data type (which operations are offered) and a data structure (how those operations are implemented) is shown with a stack example. The chapter closes with choosing a data structure and a short comparison table of the course’s core structures.

Chapter 2: Algorithm Analysis

Algorithm analysis lets us compare solutions before implementing them. Empirical timing and the doubling experiment show how running time grows in practice; counting primitive operations gives a machine-independent measure. Big O, Big Omega and Big Theta describe upper, lower and tight bounds, and the best, average and worst cases are studied separately. Loop patterns, linear and binary search, and prefix averages show how the structure of code determines its complexity. Space complexity, correctness and robustness are also covered.

Chapter 3: Arrays

An array is the most basic data structure, with its elements stored contiguously in memory; each element is reached by its index in constant time. The chapter covers declaring and copying arrays in Java, java.util.Arrays and multidimensional arrays; basic array algorithms such as mean, median, mode and reversal; matrix operations and a small tic-tac-toe game. It shows that access is O(1) while inserting and deleting in the middle are O(n) because elements must shift; selection sort and insertion sort are also studied on arrays.

Chapter 4: Recursion

Recursion reduces a problem to smaller instances of the same problem until it reaches a base case. Each recursive call gets its own frame on the call stack; tracing a recursive method means following frames as they are pushed and popped. Linear recursion (sum, reversal, fast exponentiation), binary recursion (Fibonacci, binary search), the Towers of Hanoi and backtracking examples (subsets, permutations) are worked step by step. Recurrence relations give the time and space cost of recursive algorithms; tail recursion and conversion to loops complete the chapter.

Part II: Linear Structures

Chapter 5: Linked Lists

A linked list is made of nodes, each holding data and a reference to the next node. Because it needs no contiguous memory, inserting and deleting at the head take constant time; in exchange there is no random access, and reaching an element means walking from the head. Traversal, insertion, deletion, reversal, removing duplicates and merging sorted lists in a singly linked list; sentinel nodes in a doubly linked list; and cycle detection and rotation in a circular list are the topics of this chapter.

Chapter 6: The List ADT and Java Collections

A list is an abstract data type for an ordered sequence of elements; it can grow and shrink and supports insertion, deletion, access and traversal. The chapter covers Java’s collection hierarchy (Iterable, Collection, List), traversal with Iterator and ListIterator, and safe removal during traversal. It also studies how ArrayList grows as a dynamic array and its amortized analysis, its comparison with LinkedList, the positional list ADT, Vector, CopyOnWriteArrayList and Arrays.asList.

Chapter 7: Stacks

A stack works last in, first out (LIFO): insertion (push) and removal (pop) happen only at the top. The stack ADT, its implementation with an array and with a linked list, and the cost of its operations are covered. Back/forward navigation, the call stack, bracket matching, the next greater element, a stack that tracks its minimum, solving the Towers of Hanoi with a stack and the stock span problem are applications. Conversion between infix, prefix and postfix notations and evaluating postfix expressions complete the chapter.

Chapter 8: Queues and Deques

A queue works first in, first out (FIFO): elements are added at one end (enqueue) and removed at the other (dequeue). The problem with a simple array queue, the circular queue and its index formulas, telling full from empty, growing the queue and a linked-list implementation are covered. The deque, which allows insertion and removal at both ends, is used in problems such as the sliding-window maximum. Round-robin scheduling, the Josephus problem, generating binary numbers and a queue built from two stacks are examples.

Part III: Trees

Chapter 9: Trees

A tree is a hierarchical structure of nodes connected by edges: it starts at a root, and each node has one parent and may have several children. File systems, organization charts and HTML documents are represented as trees. Basic notions such as degree, depth and height, the kinds of binary trees (full, complete, perfect) and their properties, and array and linked representations are studied. Preorder, inorder, postorder and level-order traversals are implemented both recursively and with a stack and a queue; expression trees and recursive tree functions (size, height, leaf count) are applications.

Chapter 10: Search Trees

In a binary search tree (BST), the keys in each node’s left subtree are smaller than its key and those in the right subtree are larger. Search, insertion and deletion take O(h), where h is the height of the tree: O(log n) when the tree is balanced, degrading to O(n) in the worst case. After search, insertion, successor and predecessor, three-case deletion and range queries in a BST, the AVL, red-black and splay trees, which keep the height bounded, are covered. For data on disk, multiway search trees such as the B-tree and the B+ tree keep many keys per node so the tree stays shallow.

Chapter 11: Priority Queues and Heaps

A priority queue is an abstract data type that always removes the element with the highest (or lowest) priority. After comparing the costs of unsorted and sorted list implementations, the binary heap is studied: in a max-heap every parent is greater than or equal to its children. The array representation, insertion and removal with up-heap and down-heap, the adaptable priority queue, building a heap in O(n) and heap sort are in this chapter. Java’s PriorityQueue class, the k-th largest element and a priority scheduler are example applications.

Part IV: Maps, Sets and Graphs

Chapter 12: Maps and Hash Tables

A map is an abstract data type that associates keys with values. A hash table computes a bucket index from a key with a hash function and, with well-distributed keys, performs insertion, deletion and lookup in O(1) on average; in the worst case this can rise to O(n). The properties of a good hash function, Java’s equals/hashCode contract, separate chaining and open addressing (linear probing, quadratic probing, double hashing) for resolving collisions, the load factor and resizing are the topics of this chapter. It ends with the internals of Java’s HashMap and applications such as two-sum.

Chapter 13: Sets and Disjoint Sets

A set is an unordered collection of distinct elements; it contains no duplicates. Union, intersection and difference, Java’s Set interface, and hash-based, tree-based and bit-vector implementations are compared; multisets and multimaps are also covered. The disjoint-set (union-find) structure, with union by size or rank and path compression, answers connectivity queries in nearly constant amortized time; counting connected components is one application.

Chapter 14: Graphs

A graph represents relationships between objects with vertices and edges. Unlike trees, it may contain cycles and several paths between two vertices; it may be directed or undirected, weighted or unweighted. Social networks, road maps and computer networks are modeled as graphs. Adjacency-matrix and adjacency-list representations, breadth-first search (BFS) and depth-first search (DFS), connected components, bipartite graphs, topological sorting and directed cycle detection are studied. After unweighted shortest paths and Dijkstra’s algorithm, the minimum spanning tree problem is solved with Kruskal’s algorithm using disjoint sets and Prim’s algorithm using a priority queue.