Lesson/searching algorithms

searching-algotihms/README.md

@@ -0,0 +1,13 @@
+# Searching Algortihms
+## Searching
+
+Günümüzde veriler gitgide artan bir hal alıyor. Her insanın bir bilgisayarı ve telefonu olduğunu düşünürsek, terabaytlarca veri ediyor. Arama algoritmaları ise istediğim özellikteki verinin elimdeki veri setlerinde aranıp, bulunup getirilmesi demek. Bunun hızlı olmasına önem gösterilir.
+
+1. Linear Search
+2. Binary Search
+3. Binary Search Tree
+
+
+### References:
+1. [search-algorithm](https://en.wikipedia.org/wiki/Search_algorithm)
+2. [why-we-need-searching-algorithms](https://www.bbc.co.uk/bitesize/guides/zgr2mp3/revision/1)

searching-algotihms/binary-search-tree.md

@@ -0,0 +1,88 @@
+# Binary Search Tree 
+Ram de Binary Search e gore farkli depolandigi icin bu yuzden yeni veri eklemede O(n) time complex durumu olusmaz. bos olan node a eklenerek sistem devam eder.
+- BST bir veri yapısıdır.
+
+**[7, 5, 1, 8, 3, 6, 0, 9, 4, 2]**
+
+> ilk gelen root tur, Burada root: 7 dir
+- Kuralı basit:
+
+Sol alt ağaç < kök
+
+Sağ alt ağaç > kök
+
+```
+      5
+     / \
+    3   8
+   / \   \
+  2   4   9
+```
+- BST’de arama
+
+> Ortalama durumda: O(log n)
+> Ağaç dengeliyse süper.
+
+- BST’de ekleme
+
+Yeni elemanı alırsın:
+
+Kökten başlarsın, Sağ mı sol mu diye karar verirsin ,Yaprakta eklenir.Kaydırma yok. Taşıma yok. Sadece aşağı doğru yürüyüş.
+
+- Ortalama durumda ekleme: O(log n)
+
+Ama burada evrenin küçük bir şakası var.
+
+> Eğer ağacı dengesiz kurarsan:
+
+```
+1
+ \
+  2
+   \
+    3
+     \
+      4
+```
+Bu artık ağaç değil, utanmadan liste olmuş bir şeydir.
+
+- Arama: O(n)
+- Ekleme: O(n)
+
+| Yapı                          | Arama    | Ekleme   | Gerçeklik         |
+| ----------------------------- | -------- | -------- | ----------------- |
+| Sıralı dizi + Binary Search   | O(log n) | **O(n)** | Kaydırma yüzünden |
+| Binary Search Tree (ortalama) | O(log n) | O(log n) | Yapısal           |
+| Dengesiz BST                  | O(n)     | O(n)     | Liste kılığı      |
+
+
+<img width="1362" height="733" alt="image" src="https://github.com/user-attachments/assets/ee2d3fa5-ddf0-40cb-8d8d-f174a3f9cae0" />
+
+Dizilerde (Array) Ekleme ve Arama Performansı Sıralı bir dizide arama yapmak log n zaman alırken, bu diziye yeni bir elemanı sıralı bir şekilde eklemek O(n) zaman alır. Bunun sebebi, yeni bir eleman eklendiğinde dizideki diğer elemanların yer değiştirmek (taşınmak) zorunda kalmasıdır. Bu maliyetten kurtulmak için Binary Search Tree (İkili Arama Ağacı) yapısı kullanılır.
+Binary Search Tree (BST) Yapısı ve Mantığı BST'de veriler, bağlı listelerdeki (linked list) gibi referanslar aracılığıyla tutulur; ancak burada her düğümün sağ ve sol olmak üzere iki referansı vardır,. 
+
+Temel kural şudur:
+- Bir düğümün sağ tarafında kendisinden büyük elemanlar bulunur.
+- Bir düğümün sol tarafında kendisinden küçük elemanlar bulunur.
+
+Yeni Eleman Ekleme Süreci Yeni bir eleman (örneğin 18) eklenirken en baştaki düğümden başlanarak "bu eleman büyük mü küçük mü?" sorusu sorulur. Eleman büyükse sağa, küçükse sola gidilerek uygun yer bulunur. Bu yöntemle, her soruda ağacın bir tarafı elendiği için problem sürekli yarıya iner. Eğer ağaç iyi dağılmış (dengeli) ise, bir eleman eklemek log n zamanda tamamlanır.
+
+**Zaman Karmaşıklığı:En İyi ve En Kötü Durumlar**
+
+- Average Case (Ortalama Durum): Ağaç dengeli ve elemanlar sağa-sola eşit dağılmışsa, arama ve ekleme işlemleri log n karmaşıklığındadır.
+- Worst Case (En Kötü Durum): Eğer ağaç dengesizse (örneğin sadece sol tarafa yığılmışsa), eleman eklemek veya aramak için neredeyse tüm elemanlara bakmak gerekebilir. Bu durumda zaman karmaşıklığı O(n) olur,.
+- BST ve Diziler Arasındaki Fark Dizilerin aksine, Binary Search Tree yapısında "random access" (rastgele erişim) yoktur; yani "bana beşinci elemanı getir" gibi doğrudan bir erişim yapılamaz. Ancak dengeli bir ağaçta hem arama hem de yeni eleman ekleme işlemleri log n süresinde yapılabildiği için dizilere göre çok daha hızlı sonuç verir
+- Binary searchte bu islemi yapmak time complex te O(logn) zaman aliyor ama diyelim ki yeni eleman eklemek istersek bu arrray[] e bunuda sirali olarak tut yine aramalarda kulalncam dersek bunu yapmam time complex te O(n) islem oluyor (butun elemanlar tasindigi icin bir yere tasinirken n tane islem yapmis oluyoruz yani )
+
+Burada yapacagimiz sey;
+
+Bir düğüm her iki tarafa da referans verebiliyor. Sağ ve sol olarak. Sağ tarafından kendinden büyük elemanlar, sol tarafında ise kendinden küçük elemanlar bulunacak.
+
+<img width="1194" height="614" alt="image" src="https://github.com/user-attachments/assets/35c52c7c-2342-408a-8993-c86718190f79" />
+
+- Tree'ye eleman eklemek istediğimde root'dan başlıyorum. Örnek olarak ben 26 sayısını ağaç yapısına eklemek istiyorum. Root'a soruyorum senin değerin ne 56. Baştaki açıklamamızı hatırlayalım. Sağ tarafında kendinden büyük, sol tarafında kendinden küçük elemanlar var. O yüzden sırasıyla 56 ve 30 a kadar ilerliyorum. 30 bana benim sol tarafıma geçmelisin çünkü sen benden küçüksün diyor. Karşıma 22 değerinde olan düğüm çıkıyor ve 22 den büyük olduğum için sağ tarafına bir köşe çekiyorum ve 26 sayısını bağlıyorum.
+
+## References:
+1. [binary-search-tree-nedir](https://tsafaelmali.medium.com/binary-search-tree-nedir-2e6fb0621d9)
+2. [binary-search-anlamak](https://www.buraksenyurt.com/post/Binary-Search-Tree-yi-Anlamak)
+3. [binary-search-tree-english-detail](https://www.geeksforgeeks.org/dsa/binary-search-tree-data-structure/)

searching-algotihms/binary-search.md

@@ -0,0 +1,68 @@
+# Binary Search Algorithm
+
+**Binary search bir veri yapısı değildir, bir arama algoritmasıdır. Çalışabilmesi için temel bir şartı vardır: dizi sıralı olmak zorunda.**
+
+Diyelim ki elimizde sıralı bir dizi var:
+
+`[1, 3, 5, 7, 9]`
+
+- Bu dizide bir eleman aramak:
+
+    - Zaman karmaşıklığı: O(log n)
+
+> Çünkü her adımda arama alanını ikiye bölersin. Güzel, hızlı, matematiksel bir zen durumu.
+
+Ama şimdi kritik nokta geliyor.
+
+- “Yeni eleman eklersem ne olur?”
+
+**Dizi sıralı kalmak zorunda.**
+
+Mesela 6 ekleyeceksin:
+
+`[1, 3, 5, 6, 7, 9]`
+
+Burada olan şey şu:
+
+- Doğru yeri bulmak → O(log n) (binary search ile)
+```
+Ama…
+Dizide o noktadan sonraki tüm elemanları sağa kaydırman gerekir.
+```
+- Kaydırma maliyeti:
+
+**En kötü durumda: O(n)**
+
+> Sonuç:
+
+`Binary search + ekleme = O(n)`
+
+- Yani:
+    - **Binary search hızlı arar ama ekleme/silme konusunda berbat.**
+
+İkili arama algoritması, elimizde bulunan **veri dizisini sıralı olduğunu** varsayıyor, bu durumu değiştirerek sonuca varmak istiyor.
+
+- İkili arama algoritması, **diziyi her seferinde ikiye bölerek ikili arama yapar**. Sıralı bir listem var ise benim Big-o logn olarak karşımıza çıkıyor.
+- Aradığım sayı 15 ve benim değer kümem [10,15,20,16,22,36,23] diyelim. Binary Search bu diziyi manipüle ederek şu ifadeye dönüştürüyor. [10,15,16,20,22,23,36]. 36 sayısını en yüksek sayı, 10 sayısını en düşük sayı ilan ediyor. Benim aradığım sayı ile ortada kalan sayıyı kıyaslıyor eğer benim sayım büyükse kendinden küçük bütün sayıları siliyor. Ve kendine yeni bir ortanca belirliyor. Böylelikle gereksiz arama yapmaktan kurtarıyor.
+
+<img width="1799" height="884" alt="Screenshot 2026-01-19 173533" src="https://github.com/user-attachments/assets/e2b424bf-cbfe-48a0-a029-96b25f27cdf4" />
+
+Time complexity: logn adimda istenilen degere ulasilabilir.
+Buyuk input size li islemlerde cok avantajlidir
+
+<img width="1600" height="630" alt="image" src="https://github.com/user-attachments/assets/0ccbdfa3-2fd4-4c81-827e-58fe718502f7" />
+
+
+## Example:
+
+<img width="809" height="614" alt="image" src="https://github.com/user-attachments/assets/8b177001-bbc9-46e9-80d9-4da87bfe0d93" />
+
+- En basta iki deger belirlenir lower & higher index olarak middle a bakilir.
+- orta noktayi aliyoruz aradigimiz ile orta noktayi karsialstirip gereksiz tarafi atiyoruz. problem size i -> n/2 oldu
+- sonra elde kalan listenin orta noktasi alinip eldeki aranan deger ile karsilastirilir, eleyerek devam edilir.
+
+## References:
+
+1. [binary-search](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
+2. [what-is-the-binary-search](https://www.mobilhanem.com/algoritma-dersleri-binary-search/)
+3. [binary-search-algorthims](https://www.programiz.com/dsa/binary-search)

searching-algotihms/linear-search.md

@@ -0,0 +1,15 @@
+# Linear Search Algorithm
+
+Linear search, tek tek elemanları dolandıktan sonra istediğim elemanın olup olmadığına bakmaktır.
+
+- Örneğin, [20,25,46,48] veri setini ele alalım. Benim aradığım eleman 25. İlk elemana gidiyorum ve değeri 20 sen değilsin diyorum. İkinci elemana gidiyorum ve değeri 25 evet sensin diyorum. Linear search algoritmam burada bitmiş oluyor.
+-  Big-o ya göre incelediğimizde bizim worst case'imiz neydi? Elemanın dizinin sonunda bulunmasıydı. Bu sebepten ötürü n elemanımız varsa big-o notasyonumuz otomatik olarak n oluyor.
+- Ekstra Hafiza kullanmiyor
+
+Linear Search de worst case ;
+- Aradigimizin elamanin listede en son da bulunmasi durumudur. Time Complex imiz -> O(n) olur.
+
+## References:
+
+1. [BBC-linear-search](https://www.bbc.co.uk/bitesize/guides/z7kkw6f/revision/7)
+2. [linear-search-with-code](https://www.programiz.com/dsa/linear-search)