• Leetcode 217 Contains Duplicate
• Leetcode 242 Valid Anagram
• Leetcode 001 Two Sum
• Leetcode 049 Group Anagrams
• Leetcode 347 Top K Frequent Elements
• Leetcode 271 Encode and Decode Strings
• Leetcode 238 Product of Array Except Self
• Leetcode 036 Valid Sudoku
• Leetcode 128 Longest Consecutive Sequence

needcode Two Pointers

• Leetcode 125 Valid Palindrome
• Leetcode 167 Two Sum II - Input Array Is Sorted
• Leetcode 015 3Sum
• Leetcode 011 Container With Most Water
• Leetcode 42 Trapping Rain Water

needcode Sliding Window

• Leetcode 121 Best Time to Buy and Sell Stock
• Leetcode 003 Longest Substring Without Repeating Characters
• Leetcode 424 Longest Repeating Character Replacement
• Leetcode 567 Permutation in String
• Leetcode 076 Minimum Window Substring
• Leetcode 239 Sliding Window Maximum

needcode Stack

• Leetcode 020 Valid Parentheses
• Leetcode 155 Min Stack
• Leetcode 150 Evaluate Reverse Polish Notation
• Leetcode 022 Generate Parentheses
• Leetcode 739 Daily Temperatures
• Leetcode 853 Car Fleet
• Leetcode 084 Largest Rectangle in Histogram

needcode Binary Search

• Leetcode 704 Binary Search
• Leetcode 074 Search a 2D Matrix
• Leetcode 875 Koko Eating Bananas
• Leetcode 153 Find Minimum in Rotated Sorted Array
• Leetcode 033 Search in Rotated Sorted Array
• Leetcode 981 Time Based Key-Value Store
• Leetcode 004 Median of Two Sorted Arrays

needcode Linked List

• Leetcode 206 Reverse Linked List
• Leetcode 021 Merge Two Sorted Lists
• Leetcode 141 Linked List Cycle
• Leetcode 143 Reorder List
• Leetcode 019 Remove Nth Node From End of List
• Leetcode 138 Copy List with Random Pointer
• Leetcode 002 Add Two Numbers
• Leetcode 287 Find the Duplicate Number
• Leetcode 146 LRU Cache
• Leetcode 023 Merge k Sorted Lists
• Leetcode 025 Reverse Nodes in k-Group

needcode Trees

• Leetcode 226 Invert Binary Tree
• Leetcode 104 Maximum Depth of Binary Tree
• Leetcode 543 Diameter of Binary Tree
• Leetcode 110 Balanced Binary Tree
• Leetcode 100 Same Tree
• Leetcode 572 Subtree of Another Tree
• Leetcode 235 Lowest Common Ancestor of a Binary Search Tree
• Leetcode 102 Binary Tree Level Order Traversal
• Leetcode 199 Binary Tree Right Side View
• Leetcode 1448 Count Good Nodes in Binary Tree
• Leetcode 98 Validate Binary Search Tree
• Leetcode 230 Kth Smallest Element in a BST
• Leetcode 105 Construct Binary Tree from Preorder and Inorder Traversal
• Leetcode 124 Binary Tree Maximum Path Sum
• Leetcode 297 Serialize and Deserialize Binary Tree

• Leetcode 141 Linked List Cycle
• Leetcode 876 Middle of the Linked List
• Leetcode 234 Palindrome Linked List
• Leetcode 203 Remove Linked List Elements
• Leetcode 083 Remove Duplicates from Sorted List

• Leetcode 142 Linked List Cycle II
• Leetcode 002 Add Two Numbers
• Leetcode 019 Remove Nth Node From End of List
• Leetcode 148 Sort List
• Leetcode 143 Reorder List

• Leetcode 111 Minimum Depth of Binary Tree
• Leetcode 100 Same Tree)
• Leetcode 112 Path Sum)
• Leetcode 543 Diameter of Binary Tree)
• Leetcode 617 Merge Two Binary Trees)
• Leetcode 104 Maximum Depth of Binary Tree)
• Leetcode 235 Lowest Common Ancestor of a Binary Search Tree)
• Leetcode 572 Subtree of Another Tree)
• Leetcode 226 Invert Binary Tree)
• Leetcode 110 Balanced Binary Tree
• Leetcode 257 Binary Tree Paths
• Leetcode 671 Second Minimum Node In a Binary Tree
• Leetcode 110 Balanced Binary Tree

• Leetcode 133 Clone Graph)
• Leetcode 417 Pacific Atlantic Water Flow
• Leetcode 200 Number of Islands
• Leetcode 261 Graph Valid Tree
• Leetcode 230 Kth Smallest Element in a BST
• Leetcode 207 Course Schedule
• Leetcode 210 Course Schedule II
• Leetcode 113 Path Sum II
• Leetcode 437 Path Sum III
• Leetcode 116 Populating Next Right Pointers in Each Node
• Leetcode 863 All Nodes Distance K in Binary Tree
• Leetcode 117 Populating Next Right Pointers in Each Node II
• Leetcode 654 Maximum Binary Tree
• Leetcode 105 Construct Binary Tree from Preorder and Inorder Traversal
• Leetcode 098 Validate Binary Search Tree
• Leetcode 236 Lowest Common Ancestor of a Binary Tree
• Leetcode 662 Maximum Width of Binary Tree

• Leetcode 111 Minimum Depth of Binary Tree
• Leetcode 637 Average of Levels in Binary Tree)

• Leetcode 323 Number of Connected Components inan Undirected Graph
• Leetcode 102 Binary Tree Level Order Traversal
• Leetcode 103 Binary Tree Zigzag Level Order Traversal
• Leetcode 107 Binary Tree Level Order Traversal II
• Leetcode 199 Binary Tree Right Side View

• Leetcode 070 Climbing Stairs
• Leetcode 053 Maximum Subarray
• Leetcode 303 Range Sum Query - Immutable

• Leetcode 198 House Robber
• Leetcode 213 House Robber II
• Leetcode 322 Coin Change
• Leetcode 152 Maximum Product Subarray
• Leetcode 300 Longest Increasing Subsequence
• Leetcode 005 Longest Palindromic Substring
• Leetcode 139 Word Break
• Leetcode 377 Combination Sum IV
• Leetcode 091 Decode Ways
• Leetcode 062 Unique Paths
• Leetcode 055 Jump Game
• Leetcode 647 Palindromic Substrings
• Leetcode 673 Number of Longest Increasing Subsequence
• Leetcode 416 Partition Equal Subset Sum
• Leetcode 698 Partition to K Equal Sum Subsets
• Leetcode 309 Best Time to Buy and Sell Stock with Cooldown
• Leetcode 125 Valid Palindrome
• Leetcode 509 Fibonacci Number

• Leetcode 079 Word Search
• Leetcode 784 Letter Case Permutation
• Leetcode 078 Subsets
• Leetcode 090 Subsets II
• Leetcode 046 Permutations
• Leetcode 047 Permutations II
• Leetcode 077 Combinations
• Leetcode 039 Combination Sum
• Leetcode 040 Combination Sum II
• Leetcode 216 Combination Sum III
• Leetcode 022 Generate Parentheses
• Leetcode 494 Target Sum
• Leetcode 131 Palindrome Partitioning
• Leetcode 017 Letter Combinations of a Phone Number
• Leetcode 320 Generalized Abbreviation

• Leetcode 448 Find All Numbers Disappeared in an Array
• Leetcode 136 Single Number
• Leetcode 217 Contains Duplicate
• Leetcode 268 Missing Number
• Leetcode 001 Two Sum
• Leetcode 977 Squares of a Sorted Array
• Leetcode 026 Remove Duplicates from Sorted Array
• Leetcode 066 Plus One
• Leetcode 088 Merge Sorted Array
• Leetcode 118 Pascal’s Triangle
• Leetcode 125 Valid Palindrome
• Leetcode 167 Two Sum II - Input Array Is Sorted
• Leetcode 349 Intersection of Two Arrays
• Leetcode 414 Third Maximum Number
• Leetcode 724 Find Pivot Index

Orta

• Leetcode 238 Product of Array Except Self
• Leetcode 287 Find the Duplicate Number
• Leetcode 442 Find All Duplicates in an Array
• Leetcode 073 Set Matrix Zeroes
• Leetcode 054 Spiral Matrix
• Leetcode 048 Rotate Image

needcode Arrays & Hashing

• Leetcode 217 Contains Duplicate
• Leetcode 242 Valid Anagram
• Leetcode 001 Two Sum
• Leetcode 049 Group Anagrams
• Leetcode 347 Top K Frequent Elements

Given the root of a binary tree, return the maximum width of the given tree.

The maximum width of a tree is the maximum width among all levels.

The width of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes are also counted into the length calculation.

It is guaranteed that the answer will in the range of 32-bit signed integer.

Input: root = [1,3,2,5,3,null,9]
Output: 4
Explanation: The maximum width existing in the third level with the length 4 (5,3,null,9).

Input: root = [1,3,null,5,3]
Output: 2
Explanation: The maximum width existing in the third level with the length 2 (5,3).

• Let us assign an id to each node, similar to the index of a heap. root is 1, left child = parent * 2, right child = parent * 2 + 1. Width = id(right most child) – id(left most child) + 1, so far so good. However, this kind of id system grows exponentially, it overflows even with long type with just 64 levels. To avoid that, we can remap the id with id – id(left most child of each level).

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
  def widthOfBinaryTree(self, root: TreeNode) -> int:
    ids = []
    def dfs(node: TreeNode, d: int, id: int) -> int:
      if not node: return 0
      if d == len(ids): ids.append(id)
      return max(id - ids[d] + 1, 
                 dfs(node.left, d + 1, (id - ids[d]) * 2),
                 dfs(node.right, d + 1, (id - ids[d]) * 2 + 1))
    return dfs(root, 0, 0)
        
        
        
        
        
               

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

-Our approach to this problem is to solve it recursively. In our base case, we return the current node if it is equal to ‘p’, ‘q’, or null. This way, we will receive falsy values as we recurse down a branch that does not contain either ‘p’ or ‘q’. Therefore, if either the left or right side of the current node returns null, then we know that that side of the tree does not contain the target values, and we can simply check the opposite side. We repeat this process until we arrive at a subtree that contains both target values, at which point we return the root node of the subtree.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """

        if not root:
            return root 

        if root == p or root == q: 
            return root 

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        if left and right:
            return root
        else:
            return left or right
        
        
        
        
        
               

A trie (pronounced as “try”) or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker.

Implement the Trie class:

• Trie() Initializes the trie object.
• void insert(String word) Inserts the string word into the trie.
• boolean search(String word) Returns true if the string word is in the trie (i.e., was inserted before), and false otherwise.
• boolean startsWith(String prefix) Returns true if there is a previously inserted string word that has the prefix prefix, and false otherwise.

Input
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
Output
[null, null, true, false, true, null, true]

Explanation
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple");   // return True
trie.search("app");     // return False
trie.startsWith("app"); // return True
trie.insert("app");
trie.search("app");     // return True

class TrieNode:

    def __init__(self):
        self.children = {}
        self.endOfWord = False




class Trie:

    def __init__(self):
        self.root = TrieNode()
        

    def insert(self, word: str) -> None:
        cur = self.root
        for c in word:
            if c not in cur.children:
                cur.children[c] = TrieNode()
            cur = cur.children[c]
        cur.endOfWord = True

    def search(self, word: str) -> bool:
        cur = self.root
        for c in word:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return cur.endOfWord
        

    def startsWith(self, prefix: str) -> bool:
        cur = self.root
        
        for c in prefix:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return True
        


# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)
        
        
        
        
        
               

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than the node’s key.
• The right subtree of a node contains only nodes with keys greater than the node’s key.
• Both the left and right subtrees must also be binary search trees.

Örnek 1

Input: root = [2,1,3]
Output: true

Örnek 2

Input: root = [5,1,4,null,null,3,6]
Output: false
Explanation: The root node's value is 5 but its right child's value is 4.

Çözüm

• Bir binary tree (ikili ağaç) veriliyor, bu ağacın geçerli bir Binary Search Tree (BST) olup olmadığını kontrol edeceğiz.
• BST Nedir?Her bir node (düğüm) için:
• Sol alt ağaçtaki tüm değerler: node.val’den küçük olmalı
• Sağ alt ağaçtaki tüm değerler: node.val’den büyük olmalı
• Bu kural tüm alt ağaçlar için geçerli olmalı, sadece direkt çocuklar için değil.
• inorder Traversal ile BST Kontrolü
• Eğer bir ağaç geçerli bir BST ise, inorder traversal sonucu artan sırada olur.
• Yani:Sol alt ağaç → Kök → Sağ alt ağaç şeklinde gezeriz.
• Her adımda bir önceki düğümün değerini saklarız (prev).
• Eğer şu anki düğümün değeri prev’den küçük veya eşit olursa, kural bozulmuştur → Geçerli BST değildir.
• Neden Inorder Traversal Kullanılır?BST’lerde inorder traversal sonucu sıralı olur.
• Bu yüzden tek bir değişken (prev) ile kontrol etmek mümkündür.
• Fazladan veri yapısı kullanmadan, çok sade bir şekilde kontrol yapılır.

Code

class Solution:
    def isValidBST(self, root):
        self.prev = None  # Önceki düğüm değerini saklamak için
        
        def inorder(node):
            if not node:
                return True
            
            # 1. Sol alt ağacı kontrol et
            if not inorder(node.left):
                return False
            
            # 2. Şu anki düğüm BST kuralını bozuyor mu?
            if self.prev is not None and node.val <= self.prev:
                return False  # Sıra bozuldu: geçerli BST değil
            self.prev = node.val  # Güncel değeri sakla
            
            # 3. Sağ alt ağacı kontrol et
            return inorder(node.right)
        
        return inorder(root)

               

Complexity

• Time complexity (Zaman Karmaşıklığı): O(N) → Her düğüm bir kez ziyaret edilir
• Space complexity (Alan Karmaşıklığı): O(H) → H = ağacın yüksekliği (recursive stack)

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Örnek 1

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

Örnek 2

Input: preorder = [-1], inorder = [-1]
Output: [-1]

Çözüm

• Bu soruda, preorder ve inorder dizileri verilmiş, ve bu iki traversala göre binary tree’yi yeniden oluşturmamız isteniyor.
• Binary Tree Traversal Özellikleri:
• Preorder (Root - Left - Right): İlk eleman her zaman root’tur.
• Inorder (Left - Root - Right): Root’un solundakiler sol subtree, sağındakiler sağ subtree’dir.
• Preorder’daki ilk elemanı root olarak al.
• Bu root elemanını inorder’da bul ve konumuna göre sol ve sağ alt ağaçları ayır.
• Aynı işlemi recursive olarak sol ve sağ taraflar için uygula.

Code

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder or not inorder:
            return None

        # Root node preorder'ın ilk elemanı
        root_val = preorder[0]
        root = TreeNode(root_val)

        # Root'un inorder'daki index'ini bul
        mid = inorder.index(root_val)

        # Sol ve sağ subtree'leri recursive olarak kur
        root.left = self.buildTree(preorder[1:1 + mid], inorder[:mid])
        root.right = self.buildTree(preorder[1 + mid:], inorder[mid + 1:])

        return root

                

Complexity

• Optimize Edilmiş Versiyon (O(n) zaman)
• inorder dizisindeki indeksleri bir hashmap ile önceden kaydedersen, her root’un index’ini O(1) sürede bulabilirsin:

Code

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        inorder_index_map = {val: idx for idx, val in enumerate(inorder)}
        self.preorder_index = 0

        def helper(left, right):
            if left > right:
                return None

            root_val = preorder[self.preorder_index]
            self.preorder_index += 1

            root = TreeNode(root_val)
            index = inorder_index_map[root_val]

            root.left = helper(left, index - 1)
            root.right = helper(index + 1, right)

            return root

        return helper(0, len(inorder) - 1)


                

Complexity

• Time complexity (Zaman Karmaşıklığı) :O(n²) O(n²) çünkü inorder.index() her seferinde O(n) zaman alır, toplamda n kez çağrılır.
• Space complexity (Alan Karmaşıklığı) :O(n)

A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.

The path sum of a path is the sum of the node’s values in the path.

Given the root of a binary tree, return the maximum path sum of any non-empty path.

Örnek 1

Input: root = [1,2,3]
Output: 6
Explanation: The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.

Örnek 2

Input: root = [-10,9,20,null,null,15,7]
Output: 42
Explanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.

Çözüm

• Bir binary tree veriliyor ve bu ağaçtaki herhangi bir başlangıç ve bitiş düğümü arasında giden bir path’in toplam değeri isteniyor. Bu path, bir node’dan aşağı veya yukarı doğru gidebilir ama bir node’u sadece bir kez içerebilir.
• Path’in root’tan başlaması gerekmez.
• Çözüm Stratejisi:
• Her node’da:Sol alt ağaçtan ve sağ alt ağaçtan gelen maksimum path sum’u al.
• Bu node’u içeren toplam yolu: left + node.val + right şeklinde düşün.
• Ama üst node’a dönerken ya sola ya sağa devam edebilirsin. Yani sadece node.val + max(left, right) dönülür.
• Her adımda global maksimumu güncelle.

Code

class Solution:
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        self.max_sum = float('-inf')

        def dfs(node):
            if not node:
                return 0

            # Negatif katkı yapan path'leri yok say
            left = max(dfs(node.left), 0)
            right = max(dfs(node.right), 0)

            # Şu anki node'dan geçen en iyi yol
            current_max = node.val + left + right

            # Global max'ı güncelle
            self.max_sum = max(self.max_sum, current_max)

            # Parent'a dönecek path (sadece bir yön seçilebilir)
            return node.val + max(left, right)

        dfs(root)
        return self.max_sum


                

Complexity

• Time complexity (Zaman Karmaşıklığı) :O(n)
• Space complexity (Alan Karmaşıklığı) :O(h) (h: ağacın yüksekliği)

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

Clarification: The input/output format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.

Örnek 1

Input: root = [1,2,3,null,null,4,5]
Output: [1,2,3,null,null,4,5]

Örnek 2

Input: root = []
Output: []

Çözüm

• Bir binary tree’yi string’e çeviren (serialize) ve bu string’den tekrar aynı binary tree’yi oluşturan (deserialize) iki fonksiyonu implement etmen isteniyor.
• Tree yapısını koruyarak, kayıpsız bir şekilde bu dönüşümleri yapmak gerekiyor.
• Örneğin, ağaçtaki null değerler (yani çocukları olmayan dallar) da string temsilinde yer almalı.

Code

class Codec:
    def serialize(self, root):
        if not root:
            return ""
        #Eğer ağacımız boşsa (yani root yoksa), boş bir string döndürürüz.
        res = []
        queue = deque([root])
        #Sonuçları tutmak için res listesi, BFS yapmak için de queue (bir deque) başlatıyoruz.
        while queue:
            node = queue.popleft()
            if node:
                res.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                res.append("null")

        #Kuyruktan bir düğüm alıyoruz.
        #Eğer düğüm varsa:
        #Değerini listeye ekliyoruz.
        #Sol ve sağ çocuklarını kuyruğa ekliyoruz.
        #Eğer düğüm None ise "null" olarak işaretliyoruz.
        #Bu şekilde tüm ağaç katman katman (level by level) taranıyor.

        return ",".join(res)
        #Son olarak, listeyi virgülle birleştirerek string'e çeviriyoruz.

    def deserialize(self, data):
        if not data:
            return None
        #Eğer data boşsa, ağacımız da boştur, direkt None döneriz.

        nodes = data.split(",")
        root = TreeNode(int(nodes[0]))
        queue = deque([root])
        i = 1

        #data string’ini ayırıp bir listeye çeviriyoruz.
        #İlk değer kök düğümdür.
        #BFS yapmak için bir kuyruk başlatıyoruz.
        #i pointer’ı, nodes listesinde ilerlemeyi sağlar.
        
        while queue:
            node = queue.popleft()
            if nodes[i] != "null":
                node.left = TreeNode(int(nodes[i]))
                queue.append(node.left)
            i += 1

            if nodes[i] != "null":
                node.right = TreeNode(int(nodes[i]))
                queue.append(node.right)
            i += 1
        
        #Kuyruktan bir düğüm alıp, sol ve sağ çocuklarını oluşturuyoruz (eğer "null" değilse).
        #Her oluşturulan çocuğu tekrar kuyruğa ekliyoruz ki onun da alt çocuklarını kurabilelim.

        return root


                

Complexity

• Time complexity (Zaman Karmaşıklığı) :
  • Serialize (Time) O(n)
  • Deserialize (Time) O(n)
• Space complexity (Alan Karmaşıklığı) :
  • Serialize (Space) O(n)
  • Deserialize (Space) O(n)

struct Node { int val; Node *left; Node *right; Node *next; } Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Input: root = [1,2,3,4,5,null,7]
Output: [1,#,2,3,#,4,5,7,#]
Explanation: Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level. 

Input: root = []
Output: []

• This question can be solved by Breadth First Search. It is similar with question 116. Populating Next Right Pointers in Each Node . The difference is the tree is no longer perfect binary tree.

• To point all nodes to their next right node. We are going to use BFS. We need go through each level. In each level, we will get all nodes from left to right and use next pointer to connect each other.

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        Q = collections.deque([root])
        while Q:
            size = len(Q)
            for i in range(size):
                node=Q.popleft()
                if i<size-1:
                    node.next=Q[0]
                if node.left:
                    Q.append(node.left)
                if node.right:
                    Q.append(node.right)
        return root
        
        
        
        
        
               

1. Create a root node whose value is the maximum value in nums.
2. Recursively build the left subtree on the subarray prefix to the left of the maximum value.
3. Recursively build the right subtree on the subarray suffix to the right of the maximum value. Return the maximum binary tree built from nums.

Input: nums = [3,2,1,6,0,5]
Output: [6,3,5,null,2,0,null,null,1]
Explanation: The recursive calls are as follow:
- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
        - Empty array, so no child.
        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
            - Empty array, so no child.
            - Only one element, so child is a node with value 1.
    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
        - Only one element, so child is a node with value 0.
        - Empty array, so no child.

Input: nums = [3,2,1]
Output: [3,null,2,null,1]

• Using DFS to recursively get the sub-list which contains the numbers that represented node values for left sub-stree. Convert the maximum value of current list be the root node of sub-tree. Then the left parts of list that exclusice the maximum value will constructed as left sub-stree of the current root. And the right parts of list that exclusice the maximum value will constructed as right substree of the current root.

• Conditions

• If there is no value in the list, which means there are no more nodes to construct the sub-tree, terminate the current recursion. After done the recursion, return the root node of the tree

def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        if not nums:return
        mx = max(nums)
        index=nums.index(mx)
        root = TreeNode(mx)
        root.left = self.constructMaximumBinaryTree(nums[:index])
        root.right = self.constructMaximumBinaryTree(nums[index+1:])
        return root
        
        
        
        
               

You can return the answer in any order.

Input: root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2
Output: [7,4,1]
Explanation: The nodes that are a distance 2 from the target node (with value 5) have values 7, 4, and 1.

Input: root = [1], target = 1, k = 3
Output: []

• First use DFS to construct a graph like dictionary and then use BFS to iterate K levels start from the target point.

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if root is None or root.left is None:
            return root
        root.left.next = root.right
        if root.next:
            root.right.next = root.next.left
        self.connect(root.left)
        self.connect(root.right)
        return root
        
        
        
        
               

struct Node { int val; Node *left; Node *right; Node *next; } Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Input: root = [1,2,3,4,5,6,7]
Output: [1,#,2,3,#,4,5,6,7,#]
Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each 

Input: root = []
Output: []

• This question can be solved by Depth First Search

• The tree is a perfect binary tree. So if there is left node then there must be right node. For each node, if it has left child node then we use next pointer to connect the left child node to right child node. If the node has next pointer, then the node’s right child node will use next pointer to connect to the node’s next node’s left child node.

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if root is None or root.left is None:
            return root
        root.left.next = root.right
        if root.next:
            root.right.next = root.next.left
        self.connect(root.left)
        self.connect(root.right)
        return root
        
        
        
        
               

The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).

Input: root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
Output: 3
Explanation: The paths that sum to 8 are shown.

Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
Output: 3

• This question can be solved by Depth First Search.

• We want to find all possible path that sum to the given number. Since the path does not have to start from the root, so any node can be the start of the path. We need to try every node to be the root and find if there is path from that root that sum up to the given number.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
            if not root: return 0
            def dfs(root, sum):
                res = 0
                if not root: return res
                if sum == root.val:
                    res += 1
                res += dfs(root.left, sum-root.val)
                res += dfs(root.right, sum-root.val)
                return res
            return dfs(root, sum) + self.pathSum(root.left, sum) + self.pathSum(root.right, sum)
        
                          

A root-to-leaf path is a path starting from the root and ending at any leaf node. A leaf is a node with no children.

Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
Output: [[5,4,11,2],[5,8,4,5]]
Explanation: There are two paths whose sum equals targetSum:
5 + 4 + 11 + 2 = 22
5 + 8 + 4 + 5 = 22

Input: root = [1,2,3], targetSum = 5
Output: []

• This question can be solved by Depth First Search. Similar with question 112. Path Sum II and 257. Binary Tree Paths However, this time need to list all path that sum to the given sum

• We use dfs to traversal the tree. Each time we compare the sum and the current root value if the they are same and the root does not have left child and right child (root is leaf), then we find a path that equal to give sum, we need to return the the current root value and add to it’s previous path. Otherwist, we make the sum equal to sum - root.val and continue recursively find the next root.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
            if not root:
                return []
            if not root.left and not root.right and sum == root.val:
                return [[root.val]]
            l_path = self.pathSum(root.left, sum-root.val)
            r_path = self.pathSum(root.right, sum-root.val)
            left = [[root.val]+l for l in l_path]
            right = [[root.val]+r for r in r_path]
            return left+right
        
        
               

Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.

Return the number of good nodes in the binary tree.

Örnek 1

Input: root = [3,1,4,3,null,1,5]
Output: 4
Explanation: Nodes in blue are good.
Root Node (3) is always a good node.
Node 4 -> (3,4) is the maximum value in the path starting from the root.
Node 5 -> (3,4,5) is the maximum value in the path
Node 3 -> (3,1,3) is the maximum value in the path.

Örnek 2

Input: root = [3,3,null,4,2]
Output: 3
Explanation: Node 2 -> (3, 3, 2) is not good, because "3" is higher than it.

Örnek 3

Input: root = [1]
Output: 1
Explanation: Root is considered as good.

Çözüm

• Bir binary tree (ikili ağaç) veriliyor. Bu ağaçta “good node” olarak adlandırılan düğümler şunlardır:Root’tan o düğüme giden yolda, değeri kendisinden büyük olan bir düğüm yoksa, o düğüm “good node”‘dur.
• Bu soruda, DFS (Depth First Search - Derinlik Öncelikli Arama) kullanabiliriz.
• Her düğümde, o ana kadar gördüğümüz maksimum değeri tutarız.
• Eğer şu anki düğümün değeri, bu maksimum değerden büyük veya eşitse → good node’dur.
• Not:DFS yerine BFS ile de yapılabilir ama DFS daha doğal hissettiriyor bu tarz root-to-node yol takibi gereken sorularda.DFS ile birlikte sürekli bir “max so far” taşıdığımız için ekstra veri yapısına ihtiyaç yok.

Code

class Solution:
    def goodNodes(self, root):
        def dfs(node, max_val):
            if not node:
                return 0
            
            # Bu düğüm good node mu?
            good = 1 if node.val >= max_val else 0
            
            # Yeni maksimumu hesapla
            new_max = max(max_val, node.val)
            
            # Sol ve sağ çocuklara git
            good += dfs(node.left, new_max)
            good += dfs(node.right, new_max)
            
            return good
        
        return dfs(root, root.val)

Complexity

• Time complexity (Zaman Karmaşıklığı): O(N) → Her düğüm bir kez ziyaret edilir

• Space complexity (Alan Karmaşıklığı): O(H) → H = ağacın yüksekliği (stack derinliği, balanced ise O(logN))

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Örnek 1

Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

Örnek 2

Input: root = [1,null,3]
Output: [1,3]

Çözüm

• Bir binary tree (ikili ağaç) verildiğinde, sağdan bakıldığında görülen düğümlerin listesini döndürmemiz isteniyor.
• Bu soruyu BFS (Genişlik Öncelikli Arama) veya DFS (Derinlik Öncelikli Arama) ile çözebiliriz.
• BFS (Level Order - Kuyuğa Dayalı Çözüm)
• Ağaç seviyelerini level order (katman bazlı) BFS ile gezeriz.
• Her seviyede en sağdaki düğümü alırız.
• DFS (Sağdan Öncelikli Derinlemesine Arama)
• Önce sağ çocuğa giderek DFS yaparsak, her seviyede ilk ziyaret edilen düğüm sağ taraftan görülen düğüm olur.
• Her seviyede sadece ilk düğümü ekleriz.
• Eğer ağacın çok derin olduğunu biliyorsan, BFS kullan çünkü DFS stack overflow hatasına sebep olabilir. Ama genellikle DFS daha az bellek tüketir.

Code

from collections import deque

class Solution:
    def rightSideView(self, root):
        if not root:
            return []
        
        result = []
        queue = deque([root])
        
        while queue:
            level_size = len(queue)
            
            for i in range(level_size):
                node = queue.popleft()
                
                # Eğer bu seviyenin en sağındaki düğümse
                if i == level_size - 1:
                    result.append(node.val)
                
                # Önce sol, sonra sağ çocukları ekle
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return result

Complexity

• Time complexity (Zaman Karmaşıklığı): O(N) çünkü her düğüm bir kez ziyaret edilir.

• Space complexity (Alan Karmaşıklığı): O(N) en kötü durumda kuyrukta tüm seviyedeki düğümler tutulur.

Code

class Solution:
    def rightSideView(self, root):
        result = []
        
        def dfs(node, depth):
            if not node:
                return
            
            # Eğer bu seviyede ilk kez bir düğüm ziyaret ediliyorsa, ekle
            if depth == len(result):
                result.append(node.val)
            
            # Önce sağ çocuğa git, sonra sol çocuğa
            dfs(node.right, depth + 1)
            dfs(node.left, depth + 1)
        
        dfs(root, 0)
        return result

Complexity

• Time complexity (Zaman Karmaşıklığı): O(N) çünkü her düğüm bir kez ziyaret edilir.

• Space complexity (Alan Karmaşıklığı): O(H) (H = ağacın yüksekliği, dengeli ağaçta O(logN), düz ağaçta O(N)).

Input: root = [3,9,20,null,null,15,7]
Output: [[15,7],[9,20],[3]]

Input: root = [1]
Output: [[1]]

• Soruda bize bir binary tree veriliyor ve bu binary tree dallarından başlayarak köke doğru level level değerlerini yazdırmamız isteniyor.
• Bu soru leetcode 102’ye çok benzemektedir.
• Tüm ağacı BfS kullanarak level level gezeriz ve değerleri bir listeye ekleriz.
• Elimizdeki liste kökten dala doğru oluşmuştur.Ama bizden dallardan köke uzanan bir sonuç beklenmektedir.Tek yapmamız gereken bu listeyi terse çevirerek sonucu bulmaktır.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
            if not root: return []
            queue = collections.deque([root])
            res=[]
            while queue:
                tmp = []
                for i in range(len(queue)):
                    node=queue.popleft()
                    tmp.append(node.val)
                    if node.left:
                        queue.append(node.left)
                    if node.right:
                        queue.append(node.right)
                res.append(tmp)
            return res[::-1]
        
        
               

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[20,9],[15,7]]

Input: root = [1]
Output: [[1]]

• Soruda bize bir binary tree veriliyor ve bu binary tree deki her basamağı kökten başlayarak zikzak şeklinde yazmamız isteniyor.Örneğin 0. basamak kök soldan sağa,1. basamaktaki elemanlar sağdan sola yazılacak,2. basamaktaki elemanlar yine soldan sağa yazılacak bu böyle gidecek.
• 4 liste oluşturuz s1 = [root],s2 = [],level = [],result = []
• s1 içinde root ile program akışını başlatırız.
• Sonra sırası ile s1’in içindekilerin childları s2’ye,s2’in içindeki nodeların childları s1’e atayarak ilerleriz.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        s1 = [root]
        s2 = []
        level = []
        result = []
        while s1 or s2:
            while s1:
                root = s1.pop()
                level.append(root.val)
                if root.left:
                    s2.append(root.left)
                if root.right:
                    s2.append(root.right)
            result.append(level)
            level = []
            while s2:
                root = s2.pop()
                level.append(root.val)
                if root.right:
                    s1.append(root.right)
                if root.left:
                    s1.append(root.left)
            if level != []:
                result.append(level)
                level = []
        return result
        
               

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

Örnek 1

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Örnek 2

Input: root = [1]
Output: [[1]]

Çözüm

• Bir binary tree (ikili ağaç) verildiğinde, level order traversal (seviye seviye gezme) işlemini gerçekleştirip sonucu döndürmemiz isteniyor.
• Bu soruyu BFS (Breadth-First Search) ile çözebiliriz. BFS, seviyeleri sırayla dolaşmamıza yardımcı olur. BFS için queue (kuyruk) veri yapısını kullanacağız.
• Root düğümünü kuyruğa ekle.
• Kuyruktan bir düğüm çıkar ve onun çocuklarını kuyruğa ekle.
• Aynı seviyedeki tüm düğümleri işlerken aynı listeye ekle.
• Tüm seviyeleri işleyerek sonucu döndür.

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = [] #sonuç listesini oluştururuz.
        
        q = collections.deque() #python que yapsını oluştururuz.
        q.append(root) #que ilk node olan kökü ekleriz.
        
        while q: #que içinde değer olduğu sürece
            qLen = len(q) #que boyutunu alırız.
            level = []    #ağaçdaki basamakların değerlerini burada tutacağız.[3],[9,20]...
            for i in range(qLen):
                node = q.popleft()#quedaki ilk giren değeri al(ilk giren ilk çıkar)
                if node:#node değeri var ise
                    level.append(node.val)#bunu basamağın değer listesine ekle
                    q.append(node.left) #sol dalında node var ise queya ekle
                    q.append(node.right)#sağ dalında node var ise queya ekle
            if level:#eğer basamakta değer var ise sonuç listesine ekle
                res.append(level)
        return res
        
               

Complexity

• Time complexity :O(n) Çünkü her düğümü yalnızca bir kez ziyaret ediyoruz.
• Space complexity :O(n) En kötü durumda, kuyrukta bir seviyedeki tüm düğümler tutulacağı için O(N) olabilir.

Given a tree of n nodes labelled from 0 to n - 1, and an array of n - 1 edges where edges[i] = [ai, bi] indicates that there is an undirected edge between the two nodes ai and bi in the tree, you can choose any node of the tree as the root. When you select a node x as the root, the result tree has height h. Among all possible rooted trees, those with minimum height (i.e. min(h)) are called minimum height trees (MHTs).

Return a list of all MHTs' root labels. You can return the answer in any order.

The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.

Input: n = 4, edges = [[1,0],[1,2],[1,3]]
Output: [1]
Explanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.

Input: n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
Output: [3,4]

• Given the above intuition, the problem is now reduced down to looking for all the centroid nodes in a tree-alike graph, which in addition are no more than two.

The idea is that we trim out the leaf nodes layer by layer, until we reach the core of the graph, which are the centroids nodes.

trim

Once we trim out the first layer of the leaf nodes (nodes that have only one connection), some of the non-leaf nodes would become leaf nodes.

The trimming process continues until there are only two nodes left in the graph, which are the centroids that we are looking for.

The above algorithm resembles the topological sorting algorithm which generates the order of objects based on their dependencies. For instance, in the scenario of course scheduling, the courses that have the least dependency would appear first in the order.

In our case, we trim out the leaf nodes first, which are the farther away from the centroids. At each step, the nodes we trim out are closer to the centroids than the nodes in the previous step. At the end, the trimming process terminates at the centroids nodes.

Implementation

Given the above algorithm, we could implement it via the Breadth First Search (BFS) strategy, to trim the leaf nodes layer by layer (i.e. level by level).

Initially, we would build a graph with the adjacency list from the input.

We then create a queue which would be used to hold the leaf nodes.

At the beginning, we put all the current leaf nodes into the queue.

We then run a loop until there is only two nodes left in the graph.

At each iteration, we remove the current leaf nodes from the queue. While removing the nodes, we also remove the edges that are linked to the nodes. As a consequence, some of the non-leaf nodes would become leaf nodes. And these are the nodes that would be trimmed out in the next iteration.

The iteration terminates when there are no more than two nodes left in the graph, which are the desired centroids nodes.

class Solution:
    def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:

        # edge cases
        if n <= 2:
            return [i for i in range(n)]

        # Build the graph with the adjacency list
        neighbors = [set() for i in range(n)]
        for start, end in edges:
            neighbors[start].add(end)
            neighbors[end].add(start)

        # Initialize the first layer of leaves
        leaves = []
        for i in range(n):
            if len(neighbors[i]) == 1:
                leaves.append(i)

        # Trim the leaves until reaching the centroids
        remaining_nodes = n
        while remaining_nodes > 2:
            remaining_nodes -= len(leaves)
            new_leaves = []
            # remove the current leaves along with the edges
            while leaves:
                leaf = leaves.pop()
                # the only neighbor left for the leaf node
                neighbor = neighbors[leaf].pop()
                # remove the only edge left
                neighbors[neighbor].remove(leaf)
                if len(neighbors[neighbor]) == 1:
                    new_leaves.append(neighbor)

            # prepare for the next round
            leaves = new_leaves

        # The remaining nodes are the centroids of the graph
        return leaves
               

For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1. Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.

Input: numCourses = 2, prerequisites = [[1,0]]
Output: [0,1]
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].

Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
Output: [0,2,1,3]
Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].

• Soruda bize kurs sayısı ve bu kursların ön koşullarının olduğu bir liste veriliyor.Bazı kursları almak için önce ön koşulu olan kursu almak lazım.
• Cevap olarakta tüm kursları alabileceğimiz sıralamayı dönmemiz isteniyor.
• Eğer tüm kursları alamıyorsak o zaman boş liste dönmemiz isteniyor.
• Tüm kursları alamama durumunu sağlayan şey [[1,0],[0,1]] görüldüğü gibi iki kursun birbirinin ön koşulu olup bir döngüye girmesi sonucu oluşur.

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        #ilk olarak prereq adında tüm kurslar için ön koşul listesi boş bir dict oluştururuz.
        prereq = {c:[] for c in range(numCourses)}
        #daha sonra bu dict doldururuz.Artık hangi kursun ön koşulunun hangi kurs olduğunu biliyoruz.
        for crs,pre in prerequisites:
            prereq[crs].append(pre)
        #sıralı kurs listesini döneceğimiz output listesini oluştururuz.    
        output = []
        #visit adında bir set() liste oluştururuz.Kursumuz bu listede ise zaten ziyaret etmişizdir.
        #cycle adındaki liste ise kursların ön koşul kurslarını bulmak isterken kullanacağımız liste.
        visit,cycle = set(), set()
        def dfs(crs):
            #eğer kurs ön koşul aramak için oluşturduğumuz cycle listede ise döngü oluştu False dön
            if crs in cycle:
                return False
            #eğer kurs daha önce ziyaret ettiğimiz visit listede ise tekrar uğraşma True dön
            if crs in visit:
                return True
             #kursu ön koşul döngü listesine ekle
            cycle.add(crs)
            #kursun ön koşul kursları için dfs fonksiyonunu çağır.İşte burası döngüyü oluşturan kısım.
            for pre in prereq[crs]:
                #eğer dfs false dönüyor ise direk false dön
                if dfs(pre)==False:
                    return False
            #Kursu ön koşul döngü listesinden çıkar
            cycle.remove(crs)
            #kursu ziyaret edilmiş kurslar listesine ekle
            visit.add(crs)
            #kursu cevap olarak döneceğimiz output listesine ekle
            output.append(crs)
            return True
        #listedeki tüm kurslar için dfs fonksiyonunu çağır herhangi biri false alır ise boş liste dön
        for c in range(numCourses):
            if dfs(c) ==False:
                return []
        return output
               

For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1. Return true if you can finish all courses. Otherwise, return false.

Input: numCourses = 2, prerequisites = [[1,0]]
Output: true
Explanation: There are a total of 2 courses to take. 
To take course 1 you should have finished course 0. So it is possible.

Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
Output: false
Explanation: There are a total of 2 courses to take. 
To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

• Soruda bize kurs sayısı ve bu kursların ön koşullarının olduğu bir liste veriliyor.Bazı kursları almak için önce ön koşulu olan kursu almak lazım.Tüm kursları alabiliyorsak True alamıyorsak False dönmemiz isteniyor.
• Tüm kursları alamama durumunu sağlayan şey [[1,0],[0,1]] görüldüğü gibi iki kursun birbirinin ön koşulu olup bir döngüye girmesi sonucu oluşur.

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        #ilk olarak preMap adında tüm kurslar için ön koşul listesi boş bir dict oluştururuz.
        preMap = {i:[] for i in range(numCourses)}
        #daha sonra bu dict doldururuz.Artık hangi kursun ön koşulunun hangi kurs olduğunu biliyoruz.
        for crs,pre in prerequisites:
            preMap[crs].append(pre)
        
        #şimdi yapacağımız şey visitSet adında ziyaret ettiğimiz kursları koyacağımız bir set()
        #bu sayede aynı kursu gördüğümüzde bir döngü olduğunu anlayıp False dönebiliriz
        visitSet = set()
        #dfs ana fonksiyonu yazalım
        def dfs(crs):
            #eğer kurs daha önce ziyaret edildi ise False dön
            if crs in visitSet:
                return False
            #eğer kursun bir ön koşul kursu yok ise True dön
            if preMap[crs] == []:
                return True
            #kursu ziyaret edilenlere ekle
            visitSet.add(crs)
            #kursun ön koşul kursları için dfs fonksiyonunu çağır
            for pre in preMap[crs]:
                #eğer dfs false dönüyor ise direk false dön
                if not dfs(pre):return False
            #kursu ziyaret edilmiş kurslardan çıkar
            visitSet.remove(crs)
            #bu kurs ile ilgili daha sonraki işlemlerin daha hızlı olması için önkoşul kurslarını boşalt
            preMap[crs]=[]
            return True
        #listedeki tüm kurslar için dfs fonksiyonunu çağır herhangi biri false alır ise direk false dön
        for crs in range(numCourses):
            if not dfs(crs):return False
        return True
        

               

Return any possible rearrangement of s or return "" if not possible.

Input: s = "aab"
Output: "aba"

Input: s = "aaab"
Output: ""

• We use max heap to solve this question. We need to calculate the frequence of each letter. The we store the letter and frequence as pair based on its frequence in max heap and we pop the first letter and frequence pair from heap as the pre pair and append the letter to result string. We iterate the heap, pop the letter and frequence pair from heap as current pair. We append the current letter to result string and update pre pair’s frequence to minus 1. Now if the pre letter frequence is not 0, we re-push the letter with updated frequence pair to heap and let the pre pair now equal to current pair until there is nothing in heap. If the result string is not equal to the length of given string return ‘’ otherwise return result string.

class Solution:
    def reorganizeString(self, S: str) -> str:
            if not S: return "" 
            # create a counter 
            heap = []
            for key, value in collections.Counter(S).items():
                heapq.heappush(heap,[-value,key])

            res = ""
            pre = heapq.heappop(heap)
            res+= pre[1]

            while heap: 
                curr = heapq.heappop(heap)
                res+=curr[1]

                pre[0]+=1
                if pre[0]<0:
                    heapq.heappush(heap,pre)
                pre = curr 

            return "" if len(res)!=len(S) else res
               

Note that it is the kth largest element in the sorted order, not the kth distinct element.

Input: nums = [3,2,1,5,6,4], k = 2
Output: 5

Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
Output: 4

• You can build a heap from input array and pop the heap until there k element left. Building heap is taking O(nlogn) time complexity.

def findKthLargest(self, nums: List[int], k: int) -> int:
        heapq.heapify(nums)
        amount = len(nums)
        while amount > k:
            heapq.heappop(nums)
            amount -= 1
        return nums[0]
        
        
        
        

Return the sorted string. If there are multiple answers, return any of them.

Input: s = "tree"
Output: "eert"
Explanation: 'e' appears twice while 'r' and 't' both appear once.
So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.

Input: s = "cccaaa"
Output: "aaaccc"
Explanation: Both 'c' and 'a' appear three times, so both "cccaaa" and "aaaccc" are valid answers.
Note that "cacaca" is incorrect, as the same characters must be together.

• Get frequence of each letter and push frequence and letter pair into heap. After pushed all frequence and letter pair into heap, then we pop and append the current letter*frequence to result string.

def frequencySort(self, s: str) -> str:
        heap = []
        for v, c in collections.Counter(s).items():
            heapq.heappush(heap,[-c,v])
        res = ""
        while heap:
            c, v = heapq.heappop(heap)
            res += v*-c
        return res
        
        
        
        

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Örnek 1

Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]

Örnek 2

Input: nums = [1], k = 1
Output: [1]

Çözüm

• First we need count the appearence for each element store it in dictionary. Then we iterate the dictionary, and push the value-key pair (or count-value pair) into heap, if the the heap length less than k. When heap length is greater or equal than k, we push the current value-key pair into heap and pop one from the heap in order to keep the length of the heap equal to key. After iteration, we will get the k most frequent elements pair, we only need to return the value not the count.

Code

class Solution:
    def topKFrequent(nums, k):
        # Elemanların frekansını hesapla
        count = Counter(nums)
        # En sık kullanılan k elemanı bulmak için min-heap kullan
        # Heap içinde (frekans, eleman) tuple'ları sakla
        heap = []
        for num, freq in count.items():
            heapq.heappush(heap, (-freq, num))
        
        # Heap'ten en sık kullanılan k elemanı çıkar
        return [heapq.heappop(heap)[1] for _ in range(k)][::-1]
        
        
        
        

Complexity

The distance between two points on the X-Y plane is the Euclidean distance (i.e., √(x1 - x2)2 + (y1 - y2)2).

You may return the answer in any order. The answer is guaranteed to be unique (except for the order that it is in).

Input: points = [[1,3],[-2,2]], k = 1
Output: [[-2,2]]
Explanation:
The distance between (1, 3) and the origin is sqrt(10).
The distance between (-2, 2) and the origin is sqrt(8).
Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].

Input: points = [[3,3],[5,-1],[-2,4]], k = 2
Output: [[3,3],[-2,4]]
Explanation: The answer [[-2,4],[3,3]] would also be accepted.

• Soruda bize bazı kordinatlar ve k sayısı veriliyor.Ve bizden origin noktasına en yakın k. kordinatı bulmamız isteniyor.
• Bu soruda heap kullanarak sıralama yapar ve sonucu bulabiliriz.

class Solution:
    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
        minHeap = []
        for x,y in points:
            dist = (x ** 2)+(y**2)
            minHeap.append([dist,x,y])
        
        heapq.heapify(minHeap)#minHeap listemizi heap yapısına çevirdik.
        res = []
        
        while k >0:
            dist, x, y = heapq.heappop(minHeap)#heap yapısındaki en küçük değeri getirir.:000şipğğ3jupşkldfpopğc
            
            
            
            i            k-=1
        return res
        
        
        
        

Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.

Örnek 1

Input: root = [3,1,4,null,2], k = 1
Output: 1

Örnek 2

Input: root = [5,3,6,2,4,null,null,1], k = 3
Output: 3

Çözüm

• Soruda bir Binary Search Tree (BST) veriliyor ve bu ağaçta k. en küçük elemanı bulmamız isteniyor.
• Bu klasik bir Binary Search Tree (BST) sorusu ve inorder traversal mantığıyla çok güzel çözülüyor.
• BST’de:Sol alt ağaçtaki tüm değerler: küçük,Sağ alt ağaçtaki tüm değerler: büyük
• Bu yüzden:BST’nin inorder traversal sonucu: küçükten büyüğe sıralanmış bir liste verir.
• Hedefimiz:BST’yi inorder traversal ile gezmek ,k. sıradaki elemanı bulduğumuzda hemen sonucu döndürmek

Code

class Solution:
    def kthSmallest(self, root, k):
        self.count = 0
        self.result = None

        def inorder(node):
            if not node or self.result is not None:
                return
            
            inorder(node.left)
            
            # Düğüm ziyaret edildiğinde sayacı artır
            self.count += 1
            if self.count == k:
                self.result = node.val
                return
            
            inorder(node.right)
        
        inorder(root)
        return self.result

           
        

Comple

• Time complexity (Zaman Karmaşıklığı) : O(n) denilebilir.Aslında O(n+k) n ağacın yüksekliği
• Space complexity : O(n)

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container, such that the container contains the most water.

Return the maximum amount of water a container can store.

Notice that you may not slant the container.

Örnek 1

Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49
Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

Örnek 2

Input: height = [1,1]
Output: 1

Çözüm

• Verilen bir yükseklik listesiyle en fazla suyu tutabilecek iki çizgiyi bulmanızı isteyen bir problem. Bu problemde amaç, iki çizgi arasındaki maksimum su miktarını tutan alanı hesaplamaktır. Çizgilerin konumları listelenmiş ve bunların arasındaki su hacmi, çizgilerin yüksekliği ve aralarındaki mesafe ile belirlenir.
• Bu problem genellikle “two-pointer” tekniği kullanılarak çözülür. Burada, iki işaretçi (pointer) dizinin başında ve sonunda başlar ve su tutma kapasitesini maksimize edecek şekilde içe doğru hareket ederler.
• Çalışma Mekanizması:
• İşaretçilerin İnitialize Edilmesi: left işaretçisi dizinin başında, right işaretçisi ise dizinin sonunda başlar.
• Su Kapasitesinin Hesaplanması: İki çizgi arasındaki genişlik (width) ve iki çizgi arasındaki minimum yükseklik (water_height) kullanılarak mevcut su kapasitesi hesaplanır.
• Maksimum Su Kapasitesinin Güncellenmesi: Şu ana kadar hesaplanan maksimum su kapasitesi (max_water) ile mevcut kapasite karşılaştırılır ve daha büyük olanı kaydedilir.
• İşaretçilerin Hareketi: En düşük çizgiye sahip tarafın işaretçisi bir adım içe doğru hareket eder, böylece potansiyel olarak daha yüksek bir çizgi ile daha büyük bir alan hesaplaması yapılır.
• Sonuç Döndürme: İşaretçiler birbiriyle kesişene kadar bu işlem tekrarlanır ve hesaplanan maksimum su kapasitesi döndürülür.

Code

class Solution:
    def maxArea(self, height):
        left, right = 0, len(height) - 1
        max_water = 0
        while left < right:
            # İki çizgi arasındaki mesafeyi ve en düşük çizgiyi kullanarak su kapasitesini hesapla
            width = right - left
            water_height = min(height[left], height[right])
            max_water = max(max_water, water_height * width)
            
            # Su tutma kapasitesini artırmak için daha düşük yükseklikteki çizgiyi hareket ettir
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        return max_water
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n dizinin uzunluğudur. Her eleman yalnızca bir kez işaretçiler tarafından incelenir.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra bir alan kullanılmaz ve yalnızca iki işaretçi ile çözüm sağlanır.

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

Örnek 1

Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.

Örnek 2

Input: height = [4,2,0,3,2,5]
Output: 9

Çözüm

• Verilen bir yükseklik haritası üzerinde bir yağmur sonrası kaç birim su birikebileceğini hesaplamanızı isteyen bir problem. Bu problem, belirli bir yapı üzerinde suyun nasıl toplanabileceğini modellemek için kullanılır ve bu yapı, bir dizi olarak verilen çeşitli yüksekliklerle temsil edilir.
• Bu problem, birden fazla yaklaşımla çözülebilir, ancak en yaygın yaklaşımlardan biri iki işaretçi tekniğidir. Alternatif olarak, dinamik programlama veya yığın (stack) kullanılarak da çözülebilir. İki işaretçi tekniğinde, iki işaretçi dizinin başlangıcı ve sonunda başlar ve ortada buluşana kadar hareket eder. Her bir işaretçi, o noktaya kadar gördüğü maksimum yüksekliği takip eder ve su toplama kapasitesi, her adımda bu maksimum değerler arasındaki farka dayanarak hesaplanır.
• Çalışma Mekanizması:
• İşaretçilerin İnitialize Edilmesi: left ve right işaretçileri dizinin başı ve sonunda başlar. left_max ve right_max ise o noktalardaki yüksekliklerle başlatılır.
• Su Toplama Kontrolü: İşaretçiler birbirine doğru hareket ederken, left_max ve right_max güncellenir. Eğer left_max veya right_max mevcut yükseklikten daha büyükse, fark kadar su birikintisi hesaplanır ve toplam suya eklenir.
• İşaretçilerin Hareketi: left veya right işaretçisi, karşı tarafın maksimum yüksekliğinden daha küçük olan tarafın işaretçisi bir adım hareket eder.
• Sonuç: İşaretçiler birbiriyle kesişene kadar bu işlem tekrarlanır ve hesaplanan toplam su miktarı döndürülür.

Code

class Solution:
    def trap(self, height):
        if not height:
            return 0
            
        left, right = 0, len(height) - 1
        left_max, right_max = height[left], height[right]
        water_trapped = 0
        
        while left < right:
            if height[left] < height[right]:
                if height[left] >= left_max:
                    left_max = height[left]
                else:
                    water_trapped += left_max - height[left]
                left += 1
            else:
                if height[right] >= right_max:
                    right_max = height[right]
                else:
                    water_trapped += right_max - height[right]
                right -= 1
                
        return water_trapped

        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n dizinin uzunluğudur. Dizi tam olarak bir kez taranır.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra bir alan kullanılmaz ve yalnızca iki işaretçi ve birkaç yerel değişkenle çözüm sağlanır.

Given an array of integers heights representing the histogram’s bar height where the width of each bar is 1, return the area of the largest rectangle in the histogram.

Örnek 1

Input: heights = [2,1,5,6,2,3]
Output: 10
Explanation: The above is a histogram where width of each bar is 1.
The largest rectangle is shown in the red area, which has an area = 10 units.

Örnek 2

Input: heights = [2,4]
Output: 4

Çözüm

• Bir histogramda oluşturulabilecek en büyük dikdörtgenin alanını bulmanızı ister. Histogram, çubukların yüksekliklerini temsil eden bir tam sayı dizisiyle verilir ve her çubuğun genişliği 1 birimdir.
• Girdi: Histogramın yüksekliklerini temsil eden bir tam sayı dizisi heights.
• Çıktı: Histogram içinde oluşturulabilecek en büyük dikdörtgenin alanı.
• Bu problem genellikle bir yığın (stack) kullanılarak çözülür. Yığın, yükseklikleri ve çubukların indekslerini saklayarak, her bir çubuk için sol ve sağda kendisinden daha kısa olan ilk çubuğun konumunu bulmamızı sağlar. Bu bilgi, her çubuk için potansiyel olarak oluşturulabilecek en büyük dikdörtgenin alanını hesaplamak için kullanılabilir.
• Çalışma Mekanizması:
• Yığın İnitialize Edilmesi: Yığın boş başlar ve histogramın yükseklikleri döngüyle işlenir.
• Dikdörtgen Alanının Hesaplanması: Her adımda, mevcut çubuğun yüksekliği yığındaki son çubuktan daha düşükse, yığının en üstündeki çubuk çıkarılır ve bu çubuk için maksimum dikdörtgen alanı hesaplanır. Çıkarılan çubuk, yığında kalan sonraki çubuk ile mevcut çubuk arasında bir dikdörtgen oluşturur.
• Yeni Çubukların Eklenmesi: Her çubuk, kendisinden önce gelen ve kendisinden daha yüksek olan çubukların yığına eklenmesiyle işlenir.
• Sonlandırma: Histogramın sonuna eklenen sıfır sayesinde, tüm çubuklar için hesaplama tamamlanabilir.
• Maksimum Alanın Dönüşü: Hesaplanan maksimum dikdörtgen alanı döndürülür.

Code

class Solution:
    def largestRectangleArea(self, heights):
        stack = []
        max_area = 0
        heights.append(0)  # Histogramın sonuna bir sıfır ekleyerek sonlandırma kolaylaştırılır.

        for i in range(len(heights)):
            while stack and heights[stack[-1]] > heights[i]:
                h = heights[stack.pop()]
                w = i if not stack else i - stack[-1] - 1
                max_area = max(max_area, h * w)
            stack.append(i)
        
        heights.pop()  # Eklenen sıfırı kaldır.
        return max_area


        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n çubuk sayısıdır. Her çubuk yığına en fazla bir kez eklenir ve bir kez çıkarılır.
• Space complexity (Alan Karmaşıklığı) : O(n), yığında en kötü durumda tüm çubuklar saklanabilir.

We will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.

You must solve this problem without using the library’s sort function.

Input: nums = [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Input: nums = [2,0,1]
Output: [0,1,2]

• Soruda bizden verilen rekleri sıralamamız isteniyor. Renkleri sayısal olarak 0,1,2 olarak temsil edebiliriz.Ve sıralamayı kütüphane fonksiyonları kullanmadan ayrıca ekstra bellek oluşturmadan yapmamız isteniyor.
• İlk olarak elimizde sadece 3 farklı sayı var bunları işaretçi kullanarak sıralayabiliriz.
• 3 işaretçimiz olur sol,sağ ve i .
• i ilerleteceğimiz işaretçidir.i=0 durumunda i değerini sol ile değiştiririz.i ve l indekslerini 1 arttırırız.
• i=2 durumunda i değerini sağ işaretçi ile değiştiririz. r değerini 1 azaltırız ama i değerini arttırmayız.Çünkü i değerini arttırmamız durumunda arada sayı kaçırma ihtimalimiz olur.
• i=1 durumunda bir değişiklik yapmaz sadece i indeksini 1 arttırırız.

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        l,r = 0,len(nums)-1
        i=0
        
        def swap(i,j):
            tmp = nums[i]
            nums[i] = nums[j]
            nums[j] = tmp
        
        while i<=r:
            if nums[i] == 0:
                swap(l,i)
                l += 1
            elif nums[i] == 2:
                swap(i,r)
                r-=1
                i-=1
            i +=1
        
        

Input: nums = [10,5,2,6], k = 100
Output: 8
Explanation: The 8 subarrays that have product less than 100 are:
[10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.

Input: nums = [1,2,3], k = 0
Output: 0

• Input: nums = [10, 5, 2, 6], k = 100

======== (End for loop, r = 0 snapshot) ============= [10, 5, 2, 6] r l prod = 10 cnt += 1

======== (End for loop, r = 1 snapshot) ============= [10, 5, 2, 6] r l prod = 50 cnt += 2

======== (r = 2, prod >= k snapshot) ================ [10, 5, 2, 6] r l
prod = 100, >= k, keep moving l till < k

======== (End for loop, r = 2 snapshot) ============= [10, 5, 2, 6] r l
prod = 10 cnt += 2

======== (End for loop, r = 3 snapshot) ============= [10, 5, 2, 6] r l
prod = 60 cnt += 3

class Solution(object):
    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:        
        left, prod, count = 0, 1, 0
            
        for right in range(len(nums)):
            prod *= nums[right]            
        
            while prod >= k and left <= right:                    
                prod /= nums[left]
                left += 1                        
            count += right - left + 1                
        return count
        
        

Return the sum of the three integers.

You may assume that each input would have exactly one solution.

Input: nums = [-1,2,1,-4], target = 1
Output: 2
Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

Input: nums = [0,0,0], target = 1
Output: 0

• 3Sum Closest is a follow-up question for two sum.

For 3Sum Closest, we are going to find the closest sum to the target. The closest sum could be the target itself or a number close to the target.

First, we can sort the array into ascending order. Second, we declare an integer variable called closetSum. That’s the final value we are going to return. Then we can iterate all the numbers in the array. Whenever visiting a number, we should find two numbers in the rest of array which adds the number closet to target. Once iteration finished, we get the result.

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        three_sum_closest = sys.maxsize
        
        nums = sorted(nums)
                
        for i, num in enumerate(nums):        
            l = i + 1
            r = len(nums) - 1
            #ignore the duplicate numbers
            if i > 0 and nums[i] == nums[i-1]:
                continue            
            while l < r:       
                local_sum = nums[i] + nums[l] + nums[r]
                if abs(local_sum - target)  < abs(three_sum_closest - target):
                    three_sum_closest = local_sum
                
                if local_sum <= target:
                    l += 1
                else:
                    r -= 1
        
        return three_sum_closest
        
        

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.

Notice that the solution set must not contain duplicate triplets.

Örnek 1

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

Örnek 2

Input: nums = []
Output: []

Çözüm

• Bu problem genellikle iki işaretçi yöntemi kullanılarak çözülür. Diziyi önce sıralayarak başlar, sonra her eleman için iki işaretçi (bir tanesi o elemandan hemen sonraki elemana, diğeri dizinin sonuna yerleştirilir) kullanarak toplamı sıfır olan üçlü kombinasyonları ararsınız. Çakışmaları ve tekrar eden üçlülerin oluşmasını engellemek için bazı kontroller yapılır.
• Çalışma Mekanizması:
• Diziyi Sırala: Dizi sıralanarak, iki işaretçi tekniklerinin uygulanabilmesi için hazır hale getirilir.
• Tekrar Eden Elemanların Atlaması: İlk for döngüsünde, tekrar eden elemanları atlayarak çözümde yalnızca benzersiz üçlülerin oluşmasını sağlar.
• İki İşaretçi Arama: İki işaretçi, mevcut elemanın bir sonraki elemanından başlayarak, dizinin sonuna kadar hareket eder. Üç elemanın toplamı sıfırsa bir çözüm olarak kaydedilir.
• Çakışmaları Önleme: Çözüm bulunduktan sonra, sol ve sağ işaretçiler tekrar eden değerleri atlayarak hareket ettirilir.
• Sonuç Döndürme: Tüm benzersiz çözümler bir liste olarak döndürülür.

Code

class Solution:
    def threeSum(self, nums):
        nums.sort()
        result = []
        for i in range(len(nums) - 2):
            if i > 0 and nums[i] == nums[i - 1]:
                continue  # Aynı eleman üzerinde tekrar işlem yapmayı önle
            left, right = i + 1, len(nums) - 1
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                if total == 0:
                    result.append([nums[i], nums[left], nums[right]])
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1  # Sol işaretçiyi tekrar eden elemanlar üzerinde hareket ettir
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1  # Sağ işaretçiyi tekrar eden elemanlar üzerinde hareket ettir
                    left += 1
                    right -= 1
                elif total < 0:
                    left += 1  # Toplam negatifse, toplamı artırmak için sol işaretçiyi hareket ettir
                else:
                    right -= 1  # Toplam pozitifse, toplamı azaltmak için sağ işaretçiyi hareket ettir
        return result

        
        

Complexity

• Time complexity (Zaman Karmaşıklığı): O(n^2), burada n dizinin uzunluğudur. Dizi sıralandıktan sonra, her eleman için O(n) karmaşıklığında bir iki işaretçi arama yapılır.
• Space complexity (Alan Karmaşıklığı): O(1) ya da O(n), çözüm setini saklamak dışında ekstra bir alan kullanılmaz.

Given a string s, find the length of the longest substring without repeating characters.

Örnek 1

Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

Örnek 2

Input: s = "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Çözüm

• Bir string içinde tekrar eden karakter olmadan en uzun alt diziyi bulmanızı ister. Bu problemde, alt dizinin içinde aynı karakterin birden fazla kez bulunmaması gerekmektedir.
• Girdi: Bir string s.
• Çıktı: Tekrar eden karakter içermeyen en uzun alt dizinin uzunluğu.
• Bu problem için yaygın bir yaklaşım, kaydırmalı pencere (sliding window) veya iki işaretçi tekniği ile birlikte bir hash set veya hash map kullanmaktır. Bu yöntemle, bir işaretçi sabit kalırken diğer işaretçi string boyunca kaydırılarak en uzun tekrar eden karakter içermeyen alt dizi bulunur.
• Çalışma Mekanizması:
• Değişkenlerin İnitialize Edilmesi: char_set tekrar eden karakterleri kontrol etmek için kullanılır. left ve right işaretçileri sıfırdan başlar. max_length maksimum uzunluğu takip eder.
• Döngü İle İşlem: right işaretçisi string boyunca ilerler. Her adımda, char_set içinde mevcut karakter kontrol edilir.
• Tekrar Eden Karakter Kontrolü: Eğer right işaretçisinin gösterdiği karakter zaten char_set içindeyse, bu karakter char_setten çıkarılana kadar left işaretçisi artırılır.
• Maksimum Uzunluğun Güncellenmesi: Her adımda, mevcut maksimum uzunluk, mevcut uzunluk ile karşılaştırılır ve gerekiyorsa güncellenir.
• Sonuç Dönüşü: Tüm işlemler tamamlandığında, hesaplanan maksimum uzunluk döndürülür.

Code

class Solution:
    def lengthOfLongestSubstring(self, s):
        char_set = set()
        left = 0
        max_length = 0
        
        for right in range(len(s)):
            while s[right] in char_set:
                char_set.remove(s[left])
                left += 1
            char_set.add(s[right])
            max_length = max(max_length, right - left + 1)
        
        return max_length

      

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n string s’nin uzunluğudur. Her karakter en fazla iki kez işlem görür (eklenir ve çıkarılır).
• Space complexity (Alan Karmaşıklığı) : O(min(n, m)), burada m karakter setinin boyutudur. En kötü durumda, tüm benzersiz karakterler char_set içine alınabilir.

You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.

Return the length of the longest substring containing the same letter you can get after performing the above operations.

Örnek 1

Input: s = "ABAB", k = 2
Output: 4
Explanation: Replace the two 'A's with two 'B's or vice versa.

Örnek 2

Input: s = "AABABBA", k = 1
Output: 4
Explanation: Replace the one 'A' in the middle with 'B' and form "AABBBBA".
The substring "BBBB" has the longest repeating letters, which is 4.

Çözüm

• Bir string içinde belirli bir sayıda karakter değişikliği yaparak elde edilebilecek en uzun tekrar eden karakter dizisini bulmanızı ister. Bu soruda, maksimum k karakteri değiştirerek bir karakteri diğer bir karakterle değiştirebilirsiniz, ve amacınız, en uzun aynı karakter dizisini (tek tip dizi) oluşturmaktır.
• Girdi: Bir string s ve bir tam sayı k.
• Çıktı: En fazla k karakter değiştirerek elde edilebilecek en uzun tekrar eden karakter dizisinin uzunluğu.
• Bu problem, kaydırmalı pencere (sliding window) veya iki işaretçi tekniği kullanılarak çözülebilir. Buradaki temel fikir, bir pencere içinde en fazla k değişiklik ile oluşturulabilecek en uzun alt diziyi bulmaktır. Pencere boyutu, penceredeki en yaygın karakterin sayısına ve k’ya bağlı olarak dinamik olarak ayarlanır.
• Çalışma Mekanizması:
• Değişkenlerin İnitialize Edilmesi: count karakter sayılarını tutar, max_count penceredeki en sık tekrar eden karakterin sayısını, max_length ise en uzun alt dizinin uzunluğunu tutar.
• Döngü İle İşlem: right işaretçisi string boyunca ilerler ve her karakter için count güncellenir. Ayrıca, her adımda max_count güncellenir.
• Pencere Kontrolü: Eğer pencerenin boyutu eksi içindeki en yaygın karakterin sayısı k’dan büyükse, bu, daha fazla değişiklik gerektiği anlamına gelir. Bu durumda, left işaretçisi artırılarak pencere daraltılır.
• Maksimum Uzunluğun Güncellenmesi: Pencere uygun boyutta olduğunda, max_length güncellenir.
• Sonuç Dönüşü: Tüm işlemler tamamlandığında, hesaplanan maksimum uzunluk döndürülür.

Code

class Solution:
    def characterReplacement(self, s, k):
        count = {}
        max_length = 0
        max_count = 0
        left = 0
        
        for right in range(len(s)):
            count[s[right]] = count.get(s[right], 0) + 1
            max_count = max(max_count, count[s[right]])

            # Pencere boyutu - içindeki en yaygın karakterin sayısı > k ise pencereyi daralt
            while (right - left + 1) - max_count > k:
                count[s[left]] -= 1
                left += 1
            
            # Mevcut pencere boyutu maksimum uzunluğu güncelle
            max_length = max(max_length, right - left + 1)
        
        return max_length

        
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n string s’nin uzunluğudur. Her karakter için sabit zaman işlemi yapılır.
• Space complexity (Alan Karmaşıklığı) : O(1), karakter sayısını tutmak için kullanılan alan genellikle sabittir (ASCII veya Unicode gibi sınırlı bir karakter seti varsayılırsa).

You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

Return the max sliding window.

Örnek 1

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3
Output: [3,3,5,5,6,7]
Explanation: 
Window position                Max
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

Örnek 2

Input: nums = [1], k = 1
Output: [1]

Çözüm

• Verilen bir tam sayı dizisi ve bir pencere boyutu k için, her pencere pozisyonunda maksimum değeri bulmanızı isteyen bir problem. Bu, bir dizide belirli bir boyutta sürekli kaydırılan bir pencerenin her adımında en büyük değeri belirlemeniz gerektiği anlamına gelir.
• Girdi: Tam sayılardan oluşan bir dizi nums ve bir pencere boyutu k.
• Çıktı: Her pencere için en büyük değeri içeren bir tam sayı dizisi.
• Bu problem genellikle bir çift yönlü kuyruk (deque) kullanılarak çözülür. Deque, her pencere için maksimum değeri verimli bir şekilde bulmamızı sağlar çünkü her adımda en büyük değere hızlıca erişebilir ve eski değerleri çıkarabiliriz. Deque, yalnızca en büyük değer adaylarını ve bunların indekslerini saklar, böylece dizinin kaydırılması sırasında en büyük değeri hızlıca güncelleyebiliriz.
• Çalışma Mekanizması:
• Deque Kullanımı: Deque, mevcut pencere içinde en büyük değerin indekslerini tutar.
• Geçersiz İndeksleri Çıkarma: Eğer deque’nun başındaki indeks mevcut pencere dışındaysa, çıkarılır.
• Değeri Karşılaştırma ve Ekleme: Mevcut değer, deque’nun sonundaki değerden büyükse, deque’nun sonundakiler çıkarılır, çünkü yeni değer daha büyük bir maksimum adayıdır.
• Sonuçların Güncellenmesi: İlk pencereden itibaren, her adımda deque’nun başındaki değer, en büyük değer olarak sonuç listesine eklenir.

Code

from collections import deque

class Solution:
    def maxSlidingWindow(self, nums, k):
        # Sonuç listesi ve deque
        deq = deque()
        maxima = []

        for i in range(len(nums)):
            # Deque'nun solundaki indeks geçerliliğini kaybettiğinde çıkar
            if deq and deq[0] == i - k:
                deq.popleft()

            # Yeni eleman daha büyükse eski maksimum adaylarını deque'den çıkar
            while deq and nums[i] > nums[deq[-1]]:
                deq.pop()

            # Yeni elemanın indeksini ekle
            deq.append(i)

            # İlk pencereden sonra maksimumu sonuç listesine ekle
            if i >= k - 1:
                maxima.append(nums[deq[0]])

        return maxima

     
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n), burada n nums dizisinin uzunluğudur. Her eleman için sabit sayıda işlem yapılır (her eleman yalnızca bir kez deque’ye eklenir ve bir kez çıkarılır).
• Space complexity (Alan Karmaşıklığı) : O(k), burada k pencere boyutudur. Deque, en kötü durumda pencere boyutuna eşit sayıda eleman içerebilir.

Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise.

In other words, return true if one of s1’s permutations is the substring of s2.

Örnek 1

Input: s1 = "ab", s2 = "eidbaooo"
Output: true
Explanation: s2 contains one permutation of s1 ("ba").

Örnek 2

Input: s1 = "ab", s2 = "eidboaoo"
Output: false

Çözüm

• Bir stringin (s1) permutasyonunun, başka bir string (s2) içinde alt dizi olarak bulunup bulunmadığını belirlemenizi ister. Bu, esasen s1’in herhangi bir permutasyonunun s2 içinde olup olmadığını kontrol etmek anlamına gelir.
• Girdi: İki string, s1 ve s2.
• Çıktı: Eğer s1’in herhangi bir permutasyonu s2 içinde varsa true, aksi takdirde false.
• Bu problem, kaydırmalı pencere (sliding window) ve hash map kullanılarak çözülebilir. s1 stringinin karakter frekanslarını bir hash map’te saklayarak başlanır, ardından s2 üzerinde bir pencere boyutu s1.length() ile kaydırılarak her pencere için karakter frekansları karşılaştırılır. Eğer herhangi bir noktada, s2’nin alt dizisinin karakter dağılımı s1 ile aynıysa, bu bir eşleşme olarak kabul edilir.
• Çalışma Mekanizması:
• Başlangıç Kontrolü: Eğer s1’in uzunluğu s2’den büyükse, s2 içinde s1’in permutasyonu olamaz.
• Karakter Sayma: s1 için bir Counter kullanılarak karakter frekansları hesaplanır.
• Kaydırmalı Pencere: s2 üzerinde bir döngü ile geçilir ve her adımda pencereye bir karakter eklenir. Pencerenin boyutu s1’in uzunluğundan fazla olursa, pencerenin başındaki karakter çıkarılır.
• Frekans Karşılaştırması: Her adımda, pencerenin frekans dağılımı s1’in frekans dağılımı ile karşılaştırılır. Eşleşme olması durumunda true dönülür.
• Sonuç: Eğer döngü sonunda hiçbir eşleşme bulunamazsa, false dönülür.

Code

from collections import Counter

class Solution:
    def checkInclusion(self, s1, s2):
        if len(s1) > len(s2):
            return False

        s1_count = Counter(s1)
        window_count = Counter()

        for i in range(len(s2)):
            # Pencereye yeni bir karakter ekle
            window_count[s2[i]] += 1

            # Pencere boyutunu s1'in uzunluğunda tut
            if i >= len(s1):
                if window_count[s2[i - len(s1)]] == 1:
                    del window_count[s2[i - len(s1)]]
                else:
                    window_count[s2[i - len(s1)]] -= 1

            # Pencerenin ve s1_count'un karşılaştırılması
            if window_count == s1_count:
                return True

        return False      
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(n + m), burada n s2’nin uzunluğu ve m s1’in uzunluğudur. Her karakter için sabit zamanlı işlemler yapılır.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü kullanılan veri yapıları sabit sayıda karakteri tutar ve bu sayı sınırlıdır.

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string “”.

The testcases will be generated such that the answer is unique.

Örnek 1

Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.

Örnek 2

Input: s = "a", t = "a"
Output: "a"
Explanation: The entire string s is the minimum window.

Örnek 3

Input: s = "a", t = "aa"
Output: ""
Explanation: Both 'a's from t must be included in the window.
Since the largest window of s only has one 'a', return empty string.

Çözüm

• Verilen iki string s ve t arasında, t içindeki tüm karakterleri kapsayan s stringinin en küçük alt dizisini bulmanızı ister. Bu alt dizi, t stringindeki tüm karakterleri içeren s stringinden alınmış en kısa ardışık dizi olmalıdır.
• Girdi: İki string, s ve t.
• Çıktı: s içinde, t içindeki tüm karakterleri içeren en küçük alt dizi. Eğer böyle bir alt dizi yoksa boş string döndürülür.
• Bu problem genellikle kaydırmalı pencere (sliding window) ve hash map kullanılarak çözülür. t stringindeki karakterlerin frekanslarını bir hash map’te saklayarak başlanır. Ardından, s üzerinde bir pencere kaydırarak bu pencerenin t stringindeki tüm karakterleri içerip içermediğini kontrol edersiniz. Pencere, t’deki tüm karakterleri kapsadığında, bu pencereyi olabildiğince daraltarak en küçük alt diziyi bulmaya çalışırsınız.
• Çalışma Mekanizması:
• İnitialize: dict_t t’deki karakterlerin frekansını saklar. required t’deki benzersiz karakter sayısını, formed ise şu an pencerede bulunan ve t’deki karakterleri karşılayan karakter sayısını tutar.
• Kaydırmalı Pencere: s üzerinde r (sağ) işaretçisiyle ilerlerken, pencereye karakterler eklenir. Her karakter için, window_counts güncellenir.
• Pencereyi Daraltma: Pencere t’deki tüm karakterleri içerdiğinde, l (sol) işaretçisiyle pencere daraltılarak mümkün olan en küçük boyut aranır.
• Sonuç Dönüşü: Eğer bir sonuç bulunmuşsa, bu sonuç döndürülür. Bulunamamışsa boş string döndürülür.

Code

from collections import Counter

class Solution:
    def minWindow(self, s, t):
        if not t or not s:
            return ""

        dict_t = Counter(t)
        required = len(dict_t)
        l, r = 0, 0
        formed = 0
        window_counts = {}

        ans = float("inf"), None, None  # Pencerenin boyutu, başlangıç ve bitiş indeksleri

        while r < len(s):
            character = s[r]
            window_counts[character] = window_counts.get(character, 0) + 1

            if character in dict_t and window_counts[character] == dict_t[character]:
                formed += 1

            while l <= r and formed == required:
                character = s[l]

                if r - l + 1 < ans[0]:
                    ans = (r - l + 1, l, r)

                window_counts[character] -= 1
                if character in dict_t and window_counts[character] < dict_t[character]:
                    formed -= 1

                l += 1    

            r += 1

        return "" if ans[0] == float("inf") else s[ans[1]:ans[2] + 1]
     
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(S + T), burada S ve T sırasıyla s ve t stringlerinin uzunluklarıdır.
• Space complexity (Alan Karmaşıklığı) : O(S + T), hash map için kullanılan alan nedeniyle.

You are visiting a farm that has a single row of fruit trees arranged from left to right. The trees are represented by an integer array fruits where fruits[i] is the type of fruit the ith tree produces.

You want to collect as much fruit as possible. However, the owner has some strict rules that you must follow:

You only have two baskets, and each basket can only hold a single type of fruit. There is no limit on the amount of fruit each basket can hold. Starting from any tree of your choice, you must pick exactly one fruit from every tree (including the start tree) while moving to the right. The picked fruits must fit in one of your baskets. Once you reach a tree with fruit that cannot fit in your baskets, you must stop. Given the integer array fruits, return the maximum number of fruits you can pick.

Input: fruits = [1,2,1]
Output: 3
Explanation: We can pick from all 3 trees.

Input: fruits = [0,1,2,2]
Output: 3
Explanation: We can pick from trees [1,2,2].
If we had started at the first tree, we would only pick from trees [0,1].

• General idea The input is a row of trees, and each tree bears fruit. This number represents the type of fruit (note, not the number). Let you pick the fruit from a certain position to the right continuously. There are only two baskets, and each basket can only put the same type of fruit. If there is no fruit to pick during the traversal to the right, or the fruit of the current tree cannot be placed in the fruit basket, then stop and ask how many fruits can be picked in total.

Problem solving method Now LeetCode likes to produce a situational question, it takes people a long time to understand the meaning of the question and abstract it out. If this problem is abstracted into a model, it is to find the longest continuous sub-array of an array, requiring that there are at most two different elements in this sub-array.

If the above abstraction is done, then we can easily think of using double pointers to calculate the number of all elements in the double pointer interval. This number is the number of fruits that we can pick. At the same time, in the process of moving, it is necessary to ensure that the type of elements in the double pointer interval is at most 2. When doing the question before, the Counter was used to directly count all the numbers in an interval, which would time out. Therefore, a dictionary is used for storage, and only the number of the rightmost and leftmost elements is updated each time.

The time complexity is O(N), and the space complexity is O(N).

class Solution(object):
    def totalFruit(self, tree):
        """
        :type tree: List[int]
        :rtype: int
        """
        left, right = 0, 0
        res = 0
        cnt = collections.defaultdict(int)
        while right < len(tree):
            cnt[tree[right]] += 1
            while len(cnt) > 2:
                cnt[tree[left]] -= 1
                if cnt[tree[left]] == 0:
                    del cnt[tree[left]]
                left += 1
            res = max(res, right - left + 1)
            right += 1
        return res
        
        

Given an array of positive integers nums and a positive integer target, return the minimal length of a contiguous subarray [numsl, numsl+1, …, numsr-1, numsr] of which the sum is greater than or equal to target. If there is no such subarray, return 0 instead.

Input: target = 7, nums = [2,3,1,2,4,3]
Output: 2
Explanation: The subarray [4,3] has the minimal length under the problem constraint.

Input: target = 4, nums = [1,4,4]
Output: 1

• Have two pointers, one fast, one slow to move to the right. Keep moving the faster pointer to the right as long as the sum is less than the target. Subtract the slower pointer pointing number when every time moving the slower pointer.

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        if target > sum(nums):
            return 0
        left = right = 0
        running_sum = 0
        result = sys.maxsize
        n = len(nums)
        
        while right < n:
            running_sum +=nums[right]
            
            while running_sum >= target:
                result = min(result,right - left + 1)
                running_sum -= nums[left]
                left +=1
            
            right +=1
        
        return result
        
        

Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.

An integer a is closer to x than an integer b if:

|a - x| < |b - x|, or |a - x| == |b - x| and a < b

Input: arr = [1,2,3,4,5], k = 4, x = 3
Output: [1,2,3,4]

Input: arr = [1,2,3,4,5], k = 4, x = -1
Output: [1,2,3,4]

• We can utilize binary search to find the index s which makes both s and s + k have almost the same difference to x. In each iteration, if mid + k is closer to x, it means elements from mid + 1 to mid + k are all equal or closer to x due to ascending order. Thus we can discard mid by assigning left to mid + 1. Otherwise, it means mid is equal or closer to x than mid + k so we remain mid in next comparison. In the end, we will found an index s that has the balanced range with s + k.
• neetcode gözden geçir.

class Solution:
    def findClosestElements(self, arr, k, x):
        """
        :type arr: List[int]
        :type k: int
        :type x: int
        :rtype: List[int]
        """

        # approach: use binary search to find the start which is closest to x

        left = 0
        right = len(arr) - k

        while left < right:
            mid = left + (right - left) // 2

            # mid + k is closer to x, discard mid by assigning left = mid + 1
            if x - arr[mid] > arr[mid + k] - x:
                left = mid + 1

            # mid is equal or closer to x than mid + k, remains mid as candidate
            else:
                right = mid

        # left == right, which makes both left and left + k have same diff with x
        return arr[left : left + k]
        
        

Write an efficient algorithm that searches for a target value in an m x n integer matrix. The matrix has the following properties:

Integers in each row are sorted in ascending from left to right. Integers in each column are sorted in ascending from top to bottom.

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
Output: true

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
Output: false

• Soruda bize bir matrix verliyor satırlar ve sütunlar küçükten büyüğe sıralı durumdalar.Ve bize verilen sayının bu matrix içerisinde bulunup bulunmadığı soruluyor.
• Aramaya en sol ve en üst indeksten başlarız.
• Eğer değerimiz bu indeksteki değerden küçük ise bir sol sütuna(col-1) geçeriz.
• Eğer değerimiz bu indeksteki değerden büyük ise bir alt satıra (row + 1) geçeriz.

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        if not matrix:
            return False
        row = 0
        col = len(matrix[0]) -1
        
        while row < len(matrix) and col>=0:
            cur = matrix[row][col]
            if target == cur:
                return True
            elif target < cur:
                col -= 1
            elif target > cur:
                row+=1
        return False
        
        

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right. The first integer of each row is greater than the last integer of the previous row.

Örnek 1

Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
Output: true

Örnek 2

Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
Output: false

Çözüm

• Bir matriste belirli bir hedef sayıyı ikili arama yöntemi ile bulmanızı ister. Bu matris özel bir yapıya sahiptir: her satır sıralıdır ve bir sonraki satırın ilk elemanı bir önceki satırın son elemanından büyük veya eşittir. Bu özellikler, matrisi tek boyutlu bir dizi gibi düşünerek ikili arama yapmayı mümkün kılar.
• Girdi: İki boyutlu bir tam sayı matrisi matrix ve bir hedef sayı target.
• Çıktı: Eğer target matriste varsa true, yoksa false döndür.
• Bu problem, matrisin düz bir dizi gibi ele alınabileceği ve buna göre ikili arama yapılacağı anlamına gelir. Matris elemanlarına doğrudan indeks hesaplayarak erişebilirsiniz, böylece iki boyutlu bir yapının tek boyutluymuş gibi ele alınmasını sağlayabilirsiniz.
• Çalışma Mekanizması:
• Başlangıç ve Bitiş İşaretçileri: left ve right işaretçileri matrisin başlangıç ve bitiş noktalarını belirler.
• Ortanca Değerin Hesaplanması: İkili arama yapılırken mid değeri hesaplanır ve bu değer, matrisin bir boyutlu bir diziymiş gibi ele alınarak mid_value değerine çevrilir.
• Karşılaştırma ve İşaretçilerin Güncellenmesi: Eğer mid_value, hedefe eşitse true döndürülür. Eğer hedef mid_value’den büyükse, arama alanı sağa kaydırılır; eğer küçükse sola kaydırılır.
• Sonuç: Eğer left işaretçisi right işaretçisini geçerse, hedef değer matriste bulunamamış demektir ve false döndürülür.

Code

class Solution:
    def searchMatrix(self, matrix, target):
        if not matrix:
            return False
        
        rows, cols = len(matrix), len(matrix[0])
        left, right = 0, rows * cols - 1
        
        while left <= right:
            mid = left + (right - left) // 2
            mid_value = matrix[mid // cols][mid % cols]  # Satır ve sütun indekslerini hesapla
            
            if mid_value == target:
                return True
            elif mid_value < target:
                left = mid + 1
            else:
                right = mid - 1
        
        return False

        
        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(log(mn)), burada m satır sayısı ve n sütun sayısıdır. Matris, tek boyutlu bir diziymiş gibi ele alındığı için tüm elemanlar üzerinde logaritmik zamanda arama yapılır.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra alan kullanılmaz; tüm işlemler mevcut matris üzerinde gerçekleştirilir.

Koko loves to eat bananas. There are n piles of bananas, the ith pile has piles[i] bananas. The guards have gone and will come back in h hours.

Koko can decide her bananas-per-hour eating speed of k. Each hour, she chooses some pile of bananas and eats k bananas from that pile. If the pile has less than k bananas, she eats all of them instead and will not eat any more bananas during this hour.

Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.

Return the minimum integer k such that she can eat all the bananas within h hours.

Örnek 1

Input: piles = [3,6,7,11], h = 8
Output: 4

Örnek 2

Input: piles = [30,11,23,4,20], h = 5
Output: 30

Örnek 3

Input: piles = [30,11,23,4,20], h = 6
Output: 23

Çözüm

• Koko’nun verilen miktarda muzları belirli bir zaman dilimi içinde yiyebilmesi için gereken minimum hızı bulmanızı ister. Koko her saat başı belirli bir hızda muz yiyor ve muzları yemeye devam ettiği sürece bu hızı saat başına sabit tutuyor. Sorunun amacı, Koko’nun tüm muzları belirtilen saatler içinde yiyebilmesi için gerekli minimum yeme hızını belirlemek.
• Girdi: Bir tam sayılar dizisi piles (her öğe bir muz yığınının boyutunu temsil eder) ve bir tam sayı H (Koko’nun muzları yemesi gereken maksimum saat sayısı).
• Çıktı: Koko’nun tüm muzları H saat içinde yiyebilmesi için gereken minimum hız.
• Bu problem ikili arama yöntemi kullanılarak çözülebilir. Hız aralığını daraltarak, Koko’nun tüm muzları belirlenen süre içinde yiyip yiyemeyeceğini kontrol edersiniz. Minimum hızı ve maksimum hızı belirlemek için muz yığınlarının maksimum değeri kullanılır ve bu hızlar arasında ikili arama yapılır.
• Çalışma Mekanizması:
• Hız Aralığının Belirlenmesi: Minimum hız 1, maksimum hız ise piles dizisinin maksimum değeri olarak belirlenir.
• İkili Arama: Minimum ve maksimum hız arasında ikili arama yapılır. Her adımda, orta değer (mid) kullanılarak canFinish fonksiyonu çağrılır. Bu fonksiyon, belirli bir hızda tüm muzların yenebilip yenemeyeceğini kontrol eder.
• Sonuç: İkili arama tamamlandığında, left değeri, Koko’nun tüm muzları belirlenen süre içinde yiyebilmesi için gerekli olan minimum hızı gösterir.

Code

class Solution:
    def minEatingSpeed(self, piles, H):
        def canFinish(k):
            time = 0
            for pile in piles:
                time += (pile - 1) // k + 1  # Her yığını k hızında yemek için gereken saat
            return time <= H

        left, right = 1, max(piles)  # Hız aralığı 1 ile en büyük yığın arasında
        while left < right:
            mid = (left + right) // 2
            if canFinish(mid):
                right = mid  # Daha düşük bir hızda deneyin
            else:
                left = mid + 1  # Hızı arttırın

        return left

        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(N log M), burada N piles dizisinin uzunluğu ve M maksimum muz yığını boyutudur. Her canFinish çağrısı O(N) süre alır ve ikili arama O(log M) süre alır.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra bir alan kullanılmaz; tüm işlemler girdi üzerinde yerinde gerçekleştirilir.

There is an integer array nums sorted in non-decreasing order (not necessarily with distinct values).

Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]] (0-indexed). For example, [0,1,2,4,4,4,5,6,6,7] might be rotated at pivot index 5 and become [4,5,6,6,7,0,1,2,4,4].

Given the array nums after the rotation and an integer target, return true if target is in nums, or false if it is not in nums.

You must decrease the overall operation steps as much as possible.

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

• Soruda bize liste veriliyor.Bu listedeki sayılar küçükten büyüğe sıralı iken n defa kaydırılmış olsun.Ayrıca bu listede aynı sayıdan birden fazla olabilir.Böyle bir listede bize verilen sayı var ise True bulunmuyor ise False dönmemiz isteniyor.

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        l,r = 0, len(nums) -1
        while l <=r:
            mid = (l + r)//2
            if nums[mid] == target : return True
            if (nums[l] == nums[mid]) and (nums[r] == nums[mid]):
                l,r = l+1,r-1
            elif nums[l]<=nums[mid]:
                if(nums[l]<=target) and (nums[mid]>target):
                    r=mid-1
                else:
                    l = mid + 1
            else:
                if(nums[mid]<target) and (nums[r]>=target):
                    l=mid+1
                else:
                    r=mid-1
        return False
        

A peak element is an element that is strictly greater than its neighbors.

Given an integer array nums, find a peak element, and return its index. If the array contains multiple peaks, return the index to any of the peaks.

You may imagine that nums[-1] = nums[n] = -∞.

You must write an algorithm that runs in O(log n) time.

Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and your function should return the index number 2.

Input: nums = [1,2,1,3,5,6,4]
Output: 5
Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.

• Soruda bize liste veriliyor.Bu listedeki sayılar karışık olarak verilmiş.Ve bizden tepe noktasını bulmamız isteniyor.
• Tepe noktası demek sayının solundaki ve sağındaki sayılardan büyük olması.
• İkili arama ile bu soruyu çözebiliriz.
• İlk orta noktayı bulduğumuzda eğer orta noktanın sağındaki sayı orta noktadan büyük ise bu sayı tepe değildir.
• Bu durumda sol işaretçiyi orta nokta + 1 yaparız.
• Eğer orta noktanın sağındaki sayı orta noktadan büyük değil ise sağ işaretçiyi orta nokta yaparız.

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        l,r = 0 ,len(nums)-1
        
        while l<r:
            mid=(l+r)//2
            if(nums[mid]<nums[mid+1]):
                l=mid+1
            else:
                r=mid
        return l
        

There is an integer array nums sorted in ascending order (with distinct values).

Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

You must write an algorithm with O(log n) runtime complexity.

Örnek 1

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Örnek 2

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

Çözüm

• “33. Search in Rotated Sorted Array” sorusu, önceden sıralanmış bir dizinin döndürüldüğü bir versiyonunda belirli bir hedef değeri aramanızı ister. Dizi, önce sıralanmış ve ardından belirli bir pivot noktasında döndürülmüştür, yani dizi kısmen sıralıdır.
• Girdi: Döndürülmüş bir sıralı tam sayı dizisi nums ve bir hedef sayı target.
• Çıktı: Eğer target dizide varsa, onun indeksini döndürün. Yoksa -1 döndürün.
• Bu problem, ikili arama (binary search) kullanılarak çözülebilir. Ancak, dizinin döndürülmüş olması, doğrudan ikili aramanın uygulanmasını karmaşıklaştırır. Bunun yerine, ikili arama sırasında dizinin hangi kısmının sıralı olduğunu belirleyip, target değerinin o kısımda olup olmadığını kontrol etmek gerekir.
• Çalışma Mekanizması:
• Başlangıç ve Bitiş İşaretçileri: left ve right işaretçileri dizinin başlangıç ve bitişinde başlar.
• İkili Arama: Döngü, left işaretçisi right işaretçisinden küçük veya eşit olduğu sürece devam eder.
• Pivot Kontrolü ve İkili Arama Uygulaması: Eğer sol taraf sıralıysa (nums[left] <= nums[mid]), target’ın bu aralıkta olup olmadığını kontrol edilir. Eğer aralıktaysa, arama bu yarıda devam eder. Eğer sağ taraf sıralıysa (nums[mid] <= nums[right]), target’ın bu aralıkta olup olmadığını kontrol edilir. Eğer aralıktaysa, arama bu yarıda devam eder.
• Sonuç: target bulunursa indeksi, bulunamazsa -1 döndürülür.

Code

class Solution:
    def search(self, nums, target):
        left, right = 0, len(nums) - 1
        
        while left <= right:
            mid = (left + right) // 2
            
            if nums[mid] == target:
                return mid
            
            # Sol yarı sıralı
            if nums[left] <= nums[mid]:
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            # Sağ yarı sıralı
            else:
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        
        return -1

        

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(log n), burada n dizinin uzunluğudur. İkili arama, her adımda arama alanını yarıya indirdiği için logaritmik zaman karmaşıklığına sahiptir.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra bir alan kullanılmaz, tüm işlemler mevcut dizide yapılır.

Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

Each row must contain the digits 1-9 without repetition. Each column must contain the digits 1-9 without repetition. Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition. Note:

A Sudoku board (partially filled) could be valid but is not necessarily solvable. Only the filled cells need to be validated according to the mentioned rules.

Örnek 1

Input: board = 
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
Output: true

Örnek 2

Input: board = 
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
Output: false
Explanation: Same as Example 1, except with the 5 in the top left corner being modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.

Çözüm

• Bu problem, 9x9’lik bir Sudoku tahtasının geçerli olup olmadığını kontrol etmenizi ister. Geçerli bir Sudoku tahtası, her satırda, her sütunda ve her 3x3’lük alt-karede 1’den 9’a kadar rakamların tekrarlanmadan yer almasını gerektirir.

• Bu problemi çözmek için, her satır, her sütun ve her 3x3 alt-karedeki sayıların tekrarlanıp tekrarlanmadığını kontrol etmek gerekiyor. Python’da bu kontrolü set kullanarak ve her birinin bir defaultdict içinde saklanmasını sağlayarak yapabiliriz.

• Data Yapıları Hazırlama:cols, rows, squares adında üç defaultdict(set) oluşturulur. Bunlar sırasıyla her sütun, satır ve 3x3 alt-kare için geçerli sayıları saklar.

• Tahta Üzerinde Dolaşma:9x9 tahtanın her bir hücresi (r, c) koordinatlarıyla dolaşılır.

• Boş Hücre Kontrolü:board[r][c] == “.” kontrolü ile boş hücreler atlanır.

• Geçerlilik Kontrolü:Her hücre için, o hücredeki değerin mevcut satır, sütun veya 3x3 alt-karede olup olmadığı kontrol edilir. Eğer değer zaten mevcutsa, Sudoku tahtası geçerli değildir ve fonksiyon False döndürür.

• Setlere Değer Ekleme:Çakışma tespit edilmediyse, ilgili değer ilgili satırın, sütunun ve alt-karenin setine eklenir.

• Sonuç:Eğer tahtada herhangi bir çakışma yoksa, döngüler tamamlandıktan sonra Sudoku geçerli kabul edilir ve True döndürülür.

• Not : key = (r /3, c /3) Örneğin, hücre (4, 7) için:(4 // 3) = 1 ve (7 // 3) = 2 hesaplanır.Bu yöntem, her bir hücrenin hangi 3x3 alt-kare içinde bulunduğunu kolayca saptamak için etkili bir yol sağlar. Bu da, her 3x3 alt-karedeki sayıların tekrarlanmadığını kontrol etmeyi basit ve hızlı hale getirir. Bu hesaplama, her bir alt-karenin kendine özgü bir set içermesini ve dolayısıyla her birinin içindeki değerlerin benzersiz olmasını sağlar.

Code

class Solution:
    def isValidSudoku(board):
        # Satır, sütun ve 3x3 alt-kareleri takip etmek için dictionary'ler
        cols = defaultdict(set)
        rows = defaultdict(set)
        squares = defaultdict(set)  # key = (r /3, c /3)

        for r in range(9):
            for c in range(9):
                if board[r][c] == ".":
                    continue  # Boş hücreler dikkate alınmaz
                if (
                    board[r][c] in rows[r]  # Satırda aynı değerden var mı kontrol et
                    or board[r][c] in cols[c]  # Sütunda aynı değerden var mı kontrol et
                    or board[r][c] in squares[(r // 3, c // 3)]  # İlgili 3x3 alt-karede kontrol et
                ):
                    return False  # Eğer tekrar eden bir değer varsa, Sudoku geçersizdir

                # Çakışma yoksa, değeri ilgili setlere ekle
                cols[c].add(board[r][c])
                rows[r].add(board[r][c])
                squares[(r // 3, c // 3)].add(board[r][c])

        return True  # Tüm hücreler geçerliyse, Sudoku geçerlidir
        

Complexity

• Time complexity (Zaman Karmaşıklığı): O(1), çünkü tahta her zaman 9x9’dur ve sabit sayıda işlem yapılmaktadır.
• Space complexity (Alan Karmaşıklığı): O(1), çünkü yalnızca sabit miktarda ekstra hafıza kullanılmaktadır (27 set için).

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Örnek 1

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Örnek 2

Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

Çözüm

• “4. Median of Two Sorted Arrays” sorusu, iki sıralı diziden oluşan veri kümesinin medyanını bulmanızı ister. Bu problem, genellikle iki sıralı dizi verildiğinde bunların birleşiminden oluşan dizinin medyanını etkili bir şekilde hesaplamak için tasarlanmıştır. Problemde, dizilerin boş olmadığı ve birleşimlerinin en az bir eleman içerdiği belirtilir.
• Girdi: İki sıralı tam sayı dizisi nums1 ve nums2.
• Çıktı: İki dizinin birleşiminden oluşan dizinin medyanı.
• Bu problemi çözmek için kullanılan yaygın bir yöntem, iki sıralı dizide ikili arama (binary search) kullanmaktır. Temel fikir, bir dizi içinde medyanı bulmak için kullanılan ikili arama tekniğini iki diziye uygulamaktır. Bu yaklaşım, özellikle iki dizi birleştirildiğinde medyanın belirlenmesi gerektiğinde etkilidir.
• Çalışma Mekanizması:
• Dizileri Yeniden Sıralama ve İndeks Ayarlama: Daha kısa diziyi A, diğerini B olarak ayarla. Böylece arama süreci daha hızlı olur.
• İkili Arama Uygulama: A üzerinde ikili arama yaparak, her adımda B üzerinde de uygun bir indeks hesapla. Bu indeksler medyanı belirlemek için kullanılacak.
• Koşulların Kontrolü: A ve B üzerinde bulunan elemanlar arasında karşılaştırmalar yaparak, medyanın doğru yerde olup olmadığını kontrol et.
• Sonucun Hesaplanması: Medyanı hesapla. Eğer toplam uzunluk tek sayı ise, ortadaki değeri döndür. Çift sayı ise, ortadaki iki değerin ortalamasını al.

Code

def findMedianSortedArrays(nums1, nums2):
    # Kısa olan diziyi A, diğerini B olarak adlandır
    A, B = (nums1, nums2) if len(nums1) < len(nums2) else (nums2, nums1)
    total = len(A) + len(B)
    half = total // 2

    l, r = 0, len(A) - 1
    while True:
        i = (l + r) // 2  # A'da medyan için orta nokta
        j = half - i - 2  # B'de medyan için orta nokta

        Aleft = A[i] if i >= 0 else float("-infinity")  # Sınırları kontrol et
        Aright = A[i + 1] if (i + 1) < len(A) else float("infinity")
        Bleft = B[j] if j >= 0 else float("-infinity")
        Bright = B[j + 1] if (j + 1) < len(B) else float("infinity")

        # Medyanı doğru bölgede bulduk
        if Aleft <= Bright and Bleft <= Aright:
            if total % 2:
                return min(Aright, Bright)
            return (max(Aleft, Bleft) + min(Aright, Bright)) / 2
        elif Aleft > Bright:
            r = i - 1
        else:
            l = i + 1

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(log(min(m, n))), burada m ve n iki dizinin uzunluklarıdır. Daha kısa dizi üzerinde ikili arama yapılır.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra alan kullanılmaz.

Design a time-based key-value data structure that can store multiple values for the same key at different time stamps and retrieve the key’s value at a certain timestamp.

Implement the TimeMap class:

TimeMap() Initializes the object of the data structure.

void set(String key, String value, int timestamp) Stores the key key with the value value at the given time timestamp.

String get(String key, int timestamp) Returns a value such that set was called previously, with timestamp_prev <= timestamp. If there are multiple such values, it returns the value associated with the largest timestamp_prev. If there are no values, it returns “”.

Örnek 1

Input
["TimeMap", "set", "get", "get", "set", "get", "get"]
[[], ["foo", "bar", 1], ["foo", 1], ["foo", 3], ["foo", "bar2", 4], ["foo", 4], ["foo", 5]]
Output
[null, null, "bar", "bar", null, "bar2", "bar2"]

Explanation
TimeMap timeMap = new TimeMap();
timeMap.set("foo", "bar", 1);  // store the key "foo" and value "bar" along with timestamp = 1.
timeMap.get("foo", 1);         // return "bar"
timeMap.get("foo", 3);         // return "bar", since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 is "bar".
timeMap.set("foo", "bar2", 4); // store the key "foo" and value "bar2" along with timestamp = 4.
timeMap.get("foo", 4);         // return "bar2"
timeMap.get("foo", 5);         // return "bar2"

Çözüm

• “981. Time Based Key-Value Store” sorusu, zaman damgasıyla birlikte değerlerin saklanabileceği ve sorgulanabileceği bir veri yapısı tasarlamayı gerektirir. Bu veri yapısında, bir anahtar (key) ve değer (value) çifti belirli bir zaman damgası (timestamp) ile saklanır. Ayrıca, belirli bir anahtar için belirli bir zaman damgasına kadar olan en son değeri alabilecek bir yöntem sağlanmalıdır.
• Sorunun Detayları:
• Veri yapısı, set(key, value, timestamp) ve get(key, timestamp) olmak üzere iki fonksiyonu desteklemelidir. set işlevi, verilen anahtar için verilen değeri belirtilen zaman damgası ile saklar. get işlevi, belirtilen anahtara ve zaman damgasına (veya daha öncesine) göre en son değeri döndürür. Eğer o anahtar için o zaman damgasından önce bir değer yoksa, boş bir string ("") döndürülür.
• Bu veri yapısını Python’da defaultdict ve bisect modüllerini kullanarak etkili bir şekilde uygulayabilirsiniz. Her anahtar için bir liste saklarsınız ve bu liste zaman damgası ve değer çiftlerini içerir. Zaman damgaları sıralı olarak tutulduğu için, bisect modülü ile belirli bir zaman damgasına göre arama yapabilirsiniz.
• Çalışma Mekanizması:
• Yapıcı (Constructor): defaultdict kullanarak her anahtar için bir liste oluşturur. Bu liste, (zaman damgası, değer) çiftlerini saklar.
• Set İşlemi: Belirli bir anahtar için, değeri ve zaman damgasını liste olarak saklar.
• Get İşlemi: bisect_right kullanarak, belirtilen zaman damgası veya ondan önceki en yakın zaman damgasını bulur. Eğer bir eşleşme bulunursa, o zaman damgasının değeri döndürülür. Bulunamazsa boş bir string döndürülür.

Code

from collections import defaultdict
import bisect

class TimeMap:
    def __init__(self):
        self.store = defaultdict(list)

    def set(self, key, value, timestamp):
        self.store[key].append((timestamp, value))

    def get(self, key, timestamp):
        A = self.store[key]
        i = bisect.bisect_right(A, (timestamp, chr(255)))
        return A[i-1][1] if i else ""

# Usage
obj = TimeMap()
obj.set("key1", "value1", 1)
print(obj.get("key1", 1))  # Outputs "value1"
print(obj.get("key1", 2))  # Outputs "value1" since it's the most recent before time 2

        

Complexity

• Time complexity (Zaman Karmaşıklığı) : set işlemi O(1) zamanda gerçekleşir. get işlemi, bisect_right kullanılarak logaritmik zaman karmaşıklığında, yani O(log n), burada n belirli bir anahtar için saklanan zaman damgası sayısıdır.
• Space complexity (Alan Karmaşıklığı) : O(N), burada N toplam (zaman damgası, değer) çiftlerinin sayısıdır.

Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:

[4,5,6,7,0,1,2] if it was rotated 4 times. [0,1,2,4,5,6,7] if it was rotated 7 times. Notice that rotating an array [a[0], a[1], a[2], …, a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], …, a[n-2]].

Given the sorted rotated array nums of unique elements, return the minimum element of this array.

You must write an algorithm that runs in O(log n) time.

Örnek 1

Input: nums = [3,4,5,1,2]
Output: 1
Explanation: The original array was [1,2,3,4,5] rotated 3 times.

Örnek 2

Input: nums = [4,5,6,7,0,1,2]
Output: 0
Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.

Çözüm

• “153. Find Minimum in Rotated Sorted Array” sorusu, döndürülmüş bir sıralı dizide minimum değeri bulmanızı ister. Bu dizideki elemanlar önceden sıralanmışken, belirli bir pivot noktasında döndürülmüş; örneğin, [0,1,2,4,5,6,7] dizisi [4,5,6,7,0,1,2] şeklinde döndürülmüş olabilir. Soru, bu dizi içindeki en küçük elemanı bulmanızı istemektedir.
• Girdi: Döndürülmüş bir sıralı tam sayı dizisi nums.
• Çıktı: Dizideki minimum değer.
• Bu problem genellikle ikili arama (binary search) yöntemi kullanılarak çözülür. İkili arama yöntemi, döndürülmüş bir sıralı dizide minimum değeri bulmak için uygundur çünkü dizinin bir kısmı sıralı olacak şekilde döndürülmüştür. İkili arama kullanarak, her adımda dizinin bir yarısını diğerine göre daha az sıralı olup olmadığını kontrol ederek atlayabiliriz.
• Çalışma Mekanizması:
• Başlangıç ve Bitiş İşaretçileri: İkili arama için left ve right işaretçileri dizinin başlangıç ve bitişinde başlar.
• İkili Arama: left ve right işaretçileri birbirine eşit olana kadar ikili arama devam eder.
• Arama Koşulu: Her adımda, mid noktasının değeri ile right noktasının değeri karşılaştırılır: Eğer mid noktasının değeri, right noktasının değerinden büyükse, bu durum minimum değerin mid’in sağ tarafında olduğunu gösterir ve arama alanı mid + 1 ile right arasına daraltılır. Eğer mid noktasının değeri, right noktasının değerinden küçük veya eşitse, minimum değer mid noktasında veya onun sol tarafında olabilir; böylece arama alanı left ile mid arasına daraltılır.
• Sonuç: Döngü tamamlandığında, left işaretçisi minimum değere işaret eder.

Code

class Solution:
    def findMin(self, nums):
        left, right = 0, len(nums) - 1

        while left < right:
            mid = (left + right) // 2
            if nums[mid] > nums[right]:  # Minimum değer sağ tarafta olmalı
                left = mid + 1
            else:
                right = mid  # Minimum değer burada veya sol tarafta olabilir

        return nums[left]
      
    

Complexity

• Time complexity (Zaman Karmaşıklığı) : O(log n), burada n dizinin uzunluğudur. İkili arama her adımda arama alanını yarıya indirger.
• Space complexity (Alan Karmaşıklığı) : O(1), çünkü ekstra alan kullanılmaz.

You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval and intervals is sorted in ascending order by starti. You are also given an interval newInterval = [start, end] that represents the start and end of another interval.

Insert newInterval into intervals such that intervals is still sorted in ascending order by starti and intervals still does not have any overlapping intervals (merge overlapping intervals if necessary).

Return intervals after the insertion.

Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]

Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].

• Soruda bize küçükten büyüğe sıralı bir interval listesi ve tek bir interval veriliyor.Tek verilen intervali bu listeye eklememiz isteniyor.Eğer kesişim olan bir durum var ise intervali düzenlememiz isteniyor.
• Yeni intervali eklerken bazı özel durumlar ile karşılaşabiliriz.
• Eğer yeni intervalin bitiş değeri listemizdeki intervalin başlangıcından küçük ise bu durumda yeni intervali listenin başına ekler ve sonucu döneriz.
• Eğer yeni intervalin başlangıç değeri listemizdeki intervalin bitiş değerinden büyük ise sonuç listemize listedeki intervali ekleriz.
• Bunların harici durumlarda yeni interval ve listedeki intervallerin başlangıç ve bitiş değerlerini karşılaştırarak yeni intervali güncelleriz.

class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        res = []
        
        for i in range(len(intervals)):
            if newInterval[1] < intervals[i][0]:
                res.append(newInterval)
                return res + intervals[i:]
            elif newInterval[0]>intervals[i][1]:
                res.append(intervals[i])
            else:
                newInterval = [min(newInterval[0],intervals[i][0]),max(newInterval[1],intervals[i][1])]
        res.append(newInterval)
        return res