Design an algorithm to optimally allocate a list of pods to a set of nodes in a Kubernetes cluster, considering CPU and memory constraints. Your solution should minimize resource fragmentation and maximize utilization, with a focus on time and space complexity.

The optimal allocation of pods to nodes in Kubernetes requires a bin-packing approach with heuristics. First, collect pod and node resource data (CPU, memory). Sort pods by resource demand (e.g., descending order) to prioritize larger pods. Use a greedy algorithm to place each pod on the node with the best fit (most available resources without exceeding limits). Track node utilization and avoid overcommitment. If no node fits a pod, add a new node. This minimizes fragmentation by filling nodes efficiently and balances utilization. Consider dynamic adjustments for real-time changes. Time complexity depends on sorting (O(n log n)) and placement (O(n*m)), where n = pods, m = nodes. Space complexity is O(n + m) for storing node states and pod allocations.

To optimally allocate pods to nodes, we use a greedy bin-packing algorithm. Pods are sorted by resource demand (CPU + memory) in descending order to prioritize larger pods first. For each pod, we iterate through nodes to find the one with the most available resources that can accommodate the pod without exceeding node capacity. This reduces fragmentation by filling nodes as much as possible. If no node fits the pod, a new node is added. This approach balances time complexity (O(n log n) for sorting, O(n*m) for placement) and space complexity (O(n + m) for storing node states). Utilization is maximized by filling nodes efficiently, though it’s a heuristic and may not be globally optimal. Real-time adjustments can be made by re-evaluating allocations periodically. This method ensures compliance with Kubernetes constraints and improves cluster efficiency.