Finding MK Average solution and explanation

import collections

class MKAverage:
    def __init__(self, m: int, k: int):
        self.m = m
        self.k = k
        self.stream = collections.deque()

    def addElement(self, num: int) -> None:
        self.stream.append(num)
        if len(self.stream) > self.m:
            self.stream.popleft()

    def calculateMKAverage(self) -> int:
        if len(self.stream) < self.m:
            return -1
        sorted_stream = sorted(self.stream)
        trimmed_stream = sorted_stream[self.k:self.m - self.k]
        return sum(trimmed_stream) // len(trimmed_stream)

#include <deque>
#include <vector>
#include <algorithm>

class MKAverage {
private:
    int m, k;
    std::deque<int> stream;

public:
    MKAverage(int m, int k) : m(m), k(k) {}

    void addElement(int num) {
        stream.push_back(num);
        if (stream.size() > m) {
            stream.pop_front();
        }
    }

    int calculateMKAverage() {
        if (stream.size() < m) {
            return -1;
        }
        std::vector<int> sorted_stream(stream.begin(), stream.end());
        std::sort(sorted_stream.begin(), sorted_stream.end());
        int sum = 0;
        for (int i = k; i < m - k; ++i) {
            sum += sorted_stream[i];
        }
        return sum / (m - 2 * k);
    }
};

import java.util.TreeMap;

class MKAverage {
    private int m, k, elementCount;
    private TreeMap<Integer, Integer> window;
    private TreeMap<Integer, Integer> small;
    private TreeMap<Integer, Integer> large;
    private long smallSum, largeSum, totalSum;

    public MKAverage(int m, int k) {
        this.m = m;
        this.k = k;
        this.window = new TreeMap<>();
        this.small = new TreeMap<>();
        this.large = new TreeMap<>();
        this.elementCount = 0;
    }

    public void addElement(int num) {
        // Implement logic to maintain the elements with TreeMaps
        totalSum += num;
        window.put(num, window.getOrDefault(num, 0) + 1);

        if (elementCount >= m) { // remove oldest element logic
            int oldestElement = window.firstKey(); // assume logic to get old element correctly
            totalSum -= oldestElement;
            // Implement logic to remove oldestElement from the data structures
        }

        // Implement logic to balance small, large, and window elements

        elementCount++;
    }

    public int calculateMKAverage() {
        if (elementCount < m) {
            return -1;
        }
        return (int) ((totalSum - smallSum - largeSum) / (m - 2 * k));
    }

    // Helper functions to maintain balance
}

class MKAverage {
    constructor(m, k) {
        this.m = m;
        this.k = k;
        this.stream = [];
    }

    addElement(num) {
        this.stream.push(num);
        if (this.stream.length > this.m) {
            this.stream.shift();
        }
    }

    calculateMKAverage() {
        if (this.stream.length < this.m) {
            return -1;
        }
        const sortedStream = [...this.stream].sort((a, b) => a - b);
        const trimmedStream = sortedStream.slice(this.k, this.m - this.k);
        const sum = trimmedStream.reduce((acc, v) => acc + v, 0);
        return Math.floor(sum / trimmedStream.length);
    }
}

type MKAverage struct {
	lo, mid, hi  *redblacktree.Tree
	q            []int
	m, k, s      int
	size1, size3 int
}

func Constructor(m int, k int) MKAverage {
	lo := redblacktree.NewWithIntComparator()
	mid := redblacktree.NewWithIntComparator()
	hi := redblacktree.NewWithIntComparator()
	return MKAverage{lo, mid, hi, []int{}, m, k, 0, 0, 0}
}

func (this *MKAverage) AddElement(num int) {
	merge := func(rbt *redblacktree.Tree, key, value int) {
		if v, ok := rbt.Get(key); ok {
			nxt := v.(int) + value
			if nxt == 0 {
				rbt.Remove(key)
			} else {
				rbt.Put(key, nxt)
			}
		} else {
			rbt.Put(key, value)
		}
	}

	if this.lo.Empty() || num <= this.lo.Right().Key.(int) {
		merge(this.lo, num, 1)
		this.size1++
	} else if this.hi.Empty() || num >= this.hi.Left().Key.(int) {
		merge(this.hi, num, 1)
		this.size3++
	} else {
		merge(this.mid, num, 1)
		this.s += num
	}
	this.q = append(this.q, num)
	if len(this.q) > this.m {
		x := this.q[0]
		this.q = this.q[1:]
		if _, ok := this.lo.Get(x); ok {
			merge(this.lo, x, -1)
			this.size1--
		} else if _, ok := this.hi.Get(x); ok {
			merge(this.hi, x, -1)
			this.size3--
		} else {
			merge(this.mid, x, -1)
			this.s -= x
		}
	}
	for ; this.size1 > this.k; this.size1-- {
		x := this.lo.Right().Key.(int)
		merge(this.lo, x, -1)
		merge(this.mid, x, 1)
		this.s += x
	}
	for ; this.size3 > this.k; this.size3-- {
		x := this.hi.Left().Key.(int)
		merge(this.hi, x, -1)
		merge(this.mid, x, 1)
		this.s += x
	}
	for ; this.size1 < this.k && !this.mid.Empty(); this.size1++ {
		x := this.mid.Left().Key.(int)
		merge(this.mid, x, -1)
		this.s -= x
		merge(this.lo, x, 1)
	}
	for ; this.size3 < this.k && !this.mid.Empty(); this.size3++ {
		x := this.mid.Right().Key.(int)
		merge(this.mid, x, -1)
		this.s -= x
		merge(this.hi, x, 1)
	}
}

func (this *MKAverage) CalculateMKAverage() int {
	if len(this.q) < this.m {
		return -1
	}
	return this.s / (this.m - 2*this.k)
}

/**
 * Your MKAverage object will be instantiated and called as such:
 * obj := Constructor(m, k);
 * obj.AddElement(num);
 * param_2 := obj.CalculateMKAverage();
 */