[Java][НП] - Блоковска структура

Да се имплементира генеричка класа за блок контејнер BlockContainer. Контејнерот треба да има блоковска структура, со тоа што секој блок содржи N елементи. Контејнерот треба да ги задоволува следните услови:

    константно време на пристап до секој блок O(1)
    логаритамско време на пристап до елементите во блокот O(logN)
    елементите во секој блок треба да бидат сортирани.

Класата треба да ги имплементира следните методи:

    public BlockContainer(int n) - конструктор со еден аргумент, максималниот број на елементи во блокот
    public void add(T a) - метод за додавање елемент во последниот блок од контејнерот (ако блокот е полн, се додава нов блок)
    public boolean remove(T a) - метод за бришње на елемент од последниот блок (ако се избришат сите елементи од еден блок, тогаш и блокот се брише)
    public void sort() - метод за сортирање на сите елементи во контејнерот
    public String toString() - препокривање на методот да враќа String во следниот формат: пример: [7, 8, 9],[1, 2, 3],[5, 6, 12],[4, 10, 8]




import java.util.*;
import java.util.stream.Collectors;

class Block<T extends Comparable<T>> {
    public Set<T> elements;

    public Block() {
        elements = new TreeSet<>();
    }

    public int getSize() {
        return elements.size();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (T el :
                elements) {
            sb.append(el).append(", ");
        }
        return sb.substring(0, sb.length() - 2);
    }


}

class BlockContainer<T extends Comparable<T>> {
    private int n;
    private List<Block<T>> blocks;

    public BlockContainer(int n) {
        this.n = n;
        blocks = new ArrayList<>();
    }

    public void add(T a) {

        if (!blocks.isEmpty()&&!(blocks.get(blocks.size() - 1).getSize() == n)) {
            blocks.get(blocks.size() - 1).elements.add(a);
        } else {
            Block<T> nov = new Block<>();
            nov.elements.add(a);
            blocks.add(nov);
        }


    }


    public boolean remove(T a) {
        Block<T> getLast = blocks.get(blocks.size() - 1);
        if (getLast == null) return false;
        if (getLast.getSize() == 1) {
            getLast.elements.remove(a);
            blocks.remove(getLast);
        } else {
            getLast.elements.remove(a);
        }
        return true;
    }


    public void sort() {
        ArrayList<T> elems = new ArrayList<>();
        blocks.forEach(block -> elems.addAll(block.elements));
        elems.sort(T::compareTo);

        blocks.clear();
        for (T el : elems) {
            this.add(el);
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();

        for (Block<T> block :
                blocks) {
            sb.append("[");
            sb.append(block.toString()).append("],");
        }
        String s = sb.substring(0, sb.length() - 1);
        return s;
    }


}

public class BlockContainerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int size = scanner.nextInt();
        BlockContainer<Integer> integerBC = new BlockContainer<Integer>(size);
        scanner.nextLine();
        Integer lastInteger = null;
        for (int i = 0; i < n; ++i) {
            int element = scanner.nextInt();
            lastInteger = element;
            integerBC.add(element);
        }
        System.out.println("+++++ Integer Block Container +++++");
        System.out.println(integerBC);
        System.out.println("+++++ Removing element +++++");
        integerBC.remove(lastInteger);
        System.out.println("+++++ Sorting container +++++");
        integerBC.sort();
        System.out.println(integerBC);
        BlockContainer<String> stringBC = new BlockContainer<String>(size);
        String lastString = null;
        for (int i = 0; i < n; ++i) {
            String element = scanner.next();
            lastString = element;
            stringBC.add(element);
        }
        System.out.println("+++++ String Block Container +++++");
        System.out.println(stringBC);
        System.out.println("+++++ Removing element +++++");
        stringBC.remove(lastString);
        System.out.println("+++++ Sorting container +++++");
        stringBC.sort();
        System.out.println(stringBC);
    }
}



11 2
89 12 54 11 5 1 7 8 2 4 14
abc ccc bcxs abcde fdsr aerdd fdsa fdf etie lidj trdf

Sample output

+++++ Integer Block Container +++++
[12, 89],[11, 54],[1, 5],[7, 8],[2, 4],[14]
+++++ Removing element +++++
+++++ Sorting container +++++
[1, 2],[4, 5],[7, 8],[11, 12],[54, 89]
+++++ String Block Container +++++
[abc, ccc],[abcde, bcxs],[aerdd, fdsr],[fdf, fdsa],[etie, lidj],[trdf]
+++++ Removing element +++++
+++++ Sorting container +++++
[abc, abcde],[aerdd, bcxs],[ccc, etie],[fdf, fdsa],[fdsr, lidj]