Amaliy Topshiriqlar

public static void FindDuplicates(int[] arr)
{
    Dictionary<int, int> counts = new Dictionary<int, int>();
    
    foreach (int num in arr)
    {
        if (counts.ContainsKey(num))
            counts[num]++;
        else
            counts[num] = 1;
    }
    
    foreach (var kvp in counts)
    {
        if (kvp.Value > 1)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value} marta");
        }
    }
}

public static void RotateArray(int[] arr, int k)
{
    int n = arr.length;
    k = k % n;
    
    // Reverse entire array
    Reverse(arr, 0, n - 1);
    // Reverse first k elements
    Reverse(arr, 0, k - 1);
    // Reverse remaining elements
    Reverse(arr, k, n - 1);
}

private static void Reverse(int[] arr, int start, int end)
{
    while (start < end)
    {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

public static bool IsValidParentheses(string s)
{
    Stack<char> stack = new Stack<char>();
    Dictionary<char, char> pairs = new Dictionary<char, char>
    {
        {')', '('}, {']', '['}, {'}', '{'}
    };
    
    foreach (char c in s)
    {
        if (c == '(' || c == '[' || c == '{')
        {
            stack.Push(c);
        }
        else if (c == ')' || c == ']' || c == '}')
        {
            if (stack.Count == 0 || stack.Pop() != pairs[c])
                return false;
        }
    }
    
    return stack.Count == 0;
}

public class MinStack
{
    private Stack<int> mainStack;
    private Stack<int> minStack;
    
    public MinStack()
    {
        mainStack = new Stack<int>();
        minStack = new Stack<int>();
    }
    
    public void Push(int value)
    {
        mainStack.Push(value);
        
        if (minStack.Count == 0 || value <= minStack.Peek())
        {
            minStack.Push(value);
        }
    }
    
    public int Pop()
    {
        int value = mainStack.Pop();
        
        if (value == minStack.Peek())
        {
            minStack.Pop();
        }
        
        return value;
    }
    
    public int GetMin()
    {
        return minStack.Peek();
    }
}

public static int TreeHeight(TreeNode root)
{
    if (root == null)
        return 0;
    
    int leftHeight = TreeHeight(root.Left);
    int rightHeight = TreeHeight(root.Right);
    
    return Math.Max(leftHeight, rightHeight) + 1;
}

public static int KthSmallest(TreeNode root, int k)
{
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode current = root;
    int count = 0;
    
    while (current != null || stack.Count > 0)
    {
        while (current != null)
        {
            stack.Push(current);
            current = current.Left;
        }
        
        current = stack.Pop();
        count++;
        
        if (count == k)
            return current.Data;
        
        current = current.Right;
    }
    
    return -1;
}

public class GraphCycleDetection
{
    private Dictionary<int, List<int>> adjList;
    
    public bool HasCycle()
    {
        HashSet<int> visited = new HashSet<int>();
        HashSet<int> recStack = new HashSet<int>();
        
        foreach (int vertex in adjList.Keys)
        {
            if (DFS(vertex, visited, recStack))
                return true;
        }
        
        return false;
    }
    
    private bool DFS(int vertex, HashSet<int> visited, 
                     HashSet<int> recStack)
    {
        if (recStack.Contains(vertex))
            return true;
        
        if (visited.Contains(vertex))
            return false;
        
        visited.Add(vertex);
        recStack.Add(vertex);
        
        foreach (int neighbor in adjList[vertex])
        {
            if (DFS(neighbor, visited, recStack))
                return true;
        }
        
        recStack.Remove(vertex);
        return false;
    }
}

public static int ShortestPath(Dictionary<int, List<int>> graph, 
                                int start, int end)
{
    Queue<(int vertex, int distance)> queue = 
        new Queue<(int, int)>();
    HashSet<int> visited = new HashSet<int>();
    
    queue.Enqueue((start, 0));
    visited.Add(start);
    
    while (queue.Count > 0)
    {
        var (vertex, distance) = queue.Dequeue();
        
        if (vertex == end)
            return distance;
        
        foreach (int neighbor in graph[vertex])
        {
            if (!visited.Contains(neighbor))
            {
                visited.Add(neighbor);
                queue.Enqueue((neighbor, distance + 1));
            }
        }
    }
    
    return -1; // Yo'l yo'q
}