Could you help explain how heapq._siftup(heap, ind) heapq._siftdown(heap, 0, ind) part works ?

We don't want to use heapify since that would be O(K), but we use heap.index(element) to get the index of the element, and that would take O(K) as well, right? So overall time complexity wise it does not really matter, right?

move the element to the end and delete it

heap[ind] = heap[-1] del heap[-1] i don't understand the comment. aren't you moving the element at end to ind, not ind to end?

For the C++ example, inheriting from Standard Library containers is generally considered bad practice as the containers do not provide virtual destructors.

You'd be better off creating a simple class that holds a vector and wraps the heap algorithms from .

Without heaps of course.

function find_sliding_window_median(nums, k) {
    let windowSum = 0, start = 0;
    for(let i=0; i<nums.length; i++){
      windowSum += nums[i]
      if(i >= k-1){
        nums[i-1] = (windowSum / k)
        windowSum -= nums[start]
        start++
      }
    }
    nums.length -=1
    return nums
  }

Since searching through a heap for the minimum is a O(k) operation, it's easer to just use a linked list and just insertion sort, which is what python's built in list is supposed to be. In fact, if you wanted to implement a binary search for insert and removal, then it would be O(log k) for each update operation leading to an overall time of O(n log k) which is faster than the given solution.

Why not use a sliding window pattern instead?

Does Sliding Window Median (hard) solution takes account for duplicates in the input array ?

Any feedback on this solution?

https://leetcode.com/problems/sliding-window-median/submissions/888474546/