آموزش کامل پیاده‌سازی Set در ساختمان داده

public class MyHashSet<E> {

    private final MyHashMap<E, Object> map = new MyHashMap<>();

    public boolean add(E e){

        if (map.containsKey(e)) return false;

        map.put(e, null);

        return true;
    }

    public boolean contains(E e){
        return map.containsKey(e);
    }

    public boolean remove(E e){

        if (!contains(e)) return false;

        map.remove(e);

        return true;
    }

    public int getSize() {
        return map.getSize();
    }

    public boolean isEmpty(){
       return map.isEmpty();
    }

    public Object[] toArray(){

        int size = map.getSize();
        Object[] elements = new Object[size];

        MyHashMap.Entry<E, Object>[] entries = map.toArray();

        for (int i=0; i<entries.length; i++){
            elements[i] = entries[i].getKey();
        }

        return elements;
    }

    @Override
    public String toString() {

        StringBuilder sb = new StringBuilder("[");

        Object[] array = toArray();

       for (int i=0; i<array.length; i++){
           sb.append(array[i]);
           if (i < array.length - 1){
               sb.append(", ");

           }
       }

       sb.append("]");

       return sb.toString();
    }
}
        

class MyHashSet<E> {
    private val map: MyHashMap<E?, Any?> = MyHashMap()

    val size: Int
        get() = map.size

    val isEmpty: Boolean
        get() = map.isEmpty

    fun add(e: E?): Boolean {
        if (map.containsKey(e)) return false

        map.put(e, null)

        return true
    }

    fun contains(e: E?): Boolean {
        return map.containsKey(e)
    }

    fun remove(e: E?): Boolean {
        if (!contains(e)) return false

        map.remove(e)

        return true
    }

    fun toArray(): Array<Any?> {
        val size: Int = map.size
        val elements = arrayOfNulls<Any>(size)

        val entries: Array<MyHashMap.Entry<E?, Any?>?> = map.toArray()

        for (i in entries.indices) {
            elements[i] = entries[i]?.key
        }

        return elements
    }

    override fun toString(): String {
        val sb = StringBuilder("[")

        val array = toArray()

        for (i in array.indices) {
            sb.append(array[i])
            if (i < array.size - 1) {
                sb.append(", ")
            }
        }

        sb.append("]")

        return sb.toString()
    }
}
        

class MyHashSet {
    constructor() {
        this.map = new MyHashMap();
    }

    add(e) {
        if (this.map.containsKey(e)) return false;

        this.map.put(e, null);
        return true;
    }

    contains(e) {
        return this.map.containsKey(e);
    }

    remove(e) {
        if (!this.contains(e)) return false;

        this.map.remove(e);
        return true;
    }

    getSize() {
        return this.map.getSize();
    }

    isEmpty() {
        return this.map.isEmpty();
    }

    toArray() {
        const size = this.map.getSize();
        const elements = new Array(size);

        const entries = this.map.toArray();

        for (let i = 0; i < entries.length; i++) {
            elements[i] = entries[i].getKey();
        }

        return elements;
    }

    toString() {
        let sb = "[";
        const array = this.toArray();

        for (let i = 0; i < array.length; i++) {
            sb += array[i];
            if (i < array.length - 1) {
                sb += ", ";
            }
        }

        sb += "]";
        return sb;
    }
}
        

class MyHashSet:

    def __init__(self):
        self.map = MyHashMap()

    def add(self, e):
        if self.map.contains_key(e): 
            return False

        self.map.put(e, None)
        return True

    def contains(self, e):
        return self.map.contains_key(e)

    def remove(self, e):
        if not self.contains(e): 
            return False

        self.map.remove(e)
        return True

    def get_size(self):
        return self.map._size

    def is_empty(self):
        return self.map.is_empty()

    def to_array(self):
        size = self.map._size
        elements = [None] * size

        entries = self.map.to_array()

        for i in range(len(entries)):
            elements[i] = entries[i].get_key()

        return elements

    def __str__(self):
        sb = "["
        array = self.toArray()

        for i in range(len(array)):
            sb += str(array[i])
            if i < len(array) - 1:
                sb += ", "

        sb += "]"
        return sb