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

public class MyList<E> {

    private static final int INITIAL_CAPACITY = 3;
    
    private int capacity;
    private int size;

    private E[] elements;

    public MyList(int capacity){
        this.capacity = capacity;
        elements = (E[]) new Object[capacity];
    }

    public MyList(){
        this(INITIAL_CAPACITY);
    }

    public int getSize() {
        return size;
    }

    public void add(E element){

        if (size == capacity){

            E[] array = (E[]) new Object[(capacity *= 2)];

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

            array[size++] = element;
            elements = array;

        }else {
            elements[size++] = element;
        }
    }


    public E get(int index){
        if (isEmpty())
            throw new NoSuchElementException("The list is empty");

        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("index should be between 0 to " + (size - 1));

        return elements[index];
    }

    public E remove(int index){
        if (isEmpty())
            throw new NoSuchElementException("The list is empty");

        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("index should be between 0 to " + (size - 1));

        E removedElement = elements[index];
        elements[index] = null;

        if (index < size -1){
            E[] array = (E[]) new Object[capacity];
            int count =0;
            for (int i=0; i<elements.length; i++){
                if (elements[i] != null)
                    array[count++] = elements[i];
            }

            elements = array;
        }

        size--;

        return removedElement;
    }

    public boolean isEmpty(){
        return size == 0;
    }
}
        

class MyList<E>(private var capacity: Int = INITIAL_CAPACITY) {
    var size: Int = 0
        private set

    val isEmpty: Boolean
        get() = size == 0

    private var elements: Array<E?>

    init {
        elements = arrayOfNulls<Any>(capacity) as Array<E?>
    }

    fun add(element: E?) {
        if (size == capacity) {

            val array = arrayOfNulls<Any>((2.let { capacity *= it; capacity })) as Array<E?>

            for (i in elements.indices) {
                array[i] = elements[i]
            }

            array[size++] = element
            elements = array
        } else {
            elements[size++] = element
        }
    }

    fun get(index: Int): E? {
        if (this.isEmpty) throw NoSuchElementException("The list is empty")

        if (index !in 0..<size) throw IndexOutOfBoundsException("index should be between 0 to " + (size - 1))

        return elements[index]
    }

    fun remove(index: Int): E? {
        if (this.isEmpty) throw NoSuchElementException("The list is empty")

        if (index !in 0..<size) throw IndexOutOfBoundsException("index should be between 0 to " + (size - 1))

        val removedElement = elements[index]
        elements[index] = null

        if (index < size - 1) {
            val array = arrayOfNulls<Any>(capacity) as Array<E?>
            var count = 0
            for (i in elements.indices) {
                if (elements[i] != null) array[count++] = elements[i]
            }

            elements = array
        }

        size--

        return removedElement
    }


    companion object {
        private const val INITIAL_CAPACITY = 3
    }

}
        

class MyList {
    // Static constant for initial capacity
    static INITIAL_CAPACITY = 3;

    constructor(capacity = MyList.INITIAL_CAPACITY) {
        this.capacity = capacity;
        this.size = 0;
        this.elements = new Array(capacity).fill(null);
    }

    getSize() {
        return this.size;
    }

    add(element) {
        if (this.size === this.capacity) {
            this.capacity *= 2;
            const newArray = new Array(this.capacity).fill(null);

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

            newArray[this.size++] = element;
            this.elements = newArray;
        } else {
            this.elements[this.size++] = element;
        }
    }

    get(index) {
        if (this.isEmpty()) {
            throw new Error("The list is empty"); // Approximate for NoSuchElementException
        }

        if (index < 0 || index >= this.size) {
            throw new RangeError("index should be between 0 to " + (this.size - 1));
        }

        return this.elements[index];
    }

    remove(index) {
        if (this.isEmpty()) {
            throw new Error("The list is empty");
        }

        if (index < 0 || index >= this.size) {
            throw new RangeError("index should be between 0 to " + (this.size - 1));
        }

        const removedElement = this.elements[index];
        this.elements[index] = null;

        if (index < this.size - 1) {
            const newArray = new Array(this.capacity).fill(null);
            let count = 0;
            for (let i = 0; i < this.elements.length; i++) {
                if (this.elements[i] !== null) {
                    newArray[count++] = this.elements[i];
                }
            }
            this.elements = newArray;
        }

        this.size--;
        return removedElement;
    }

    isEmpty() {
        return this.size === 0;
    }
}
        

class MyList:
    INITIAL_CAPACITY = 3

    def __init__(self, capacity=INITIAL_CAPACITY):
        self.capacity = capacity
        self._size = 0
        self.elements = [None] * capacity

    def get_size(self):
        return self._size

    def add(self, element):
        if self._size == self.capacity:
            self.capacity *= 2
            new_array = [None] * self.capacity

            for i in range(len(self.elements)):
                new_array[i] = self.elements[i]

            new_array[self._size] = element
            self._size += 1
            self.elements = new_array
        else:
            self.elements[self._size] = element
            self._size += 1

    def get(self, index):
        if self.is_empty():
            raise ValueError("The list is empty")

        if index < 0 or index >= self._size:
            raise IndexError("index should be between 0 to " + str(self._size - 1))

        return self.elements[index]

    def remove(self, index):
        if self.is_empty():
            raise ValueError("The list is empty")

        if index < 0 or index >= self._size:
            raise IndexError("index should be between 0 to " + str(self._size - 1))

        removed_element = self.elements[index]
        self.elements[index] = None

        if index < self._size - 1:
            new_array = [None] * self.capacity
            count = 0
            for i in range(len(self.elements)):
                if self.elements[i] is not None:
                    new_array[count] = self.elements[i]
                    count += 1
            self.elements = new_array

        self._size -= 1
        return removed_element

    def is_empty(self):
        return self._size == 0
        

public class MyStack<E> {
    
    private final MyList<E> list = new MyList<>();
    
    public MyStack(E[] elements){
        for (int i=0; i<elements.length; i++){
            list.add(elements[i]);
        }
    }
    
    public MyStack(){
        
    }
    
    public boolean push(E e){
        return list.add(e);
    }
    
    public E peek(){
        if (list.isEmpty()) return null;
        return list.get(list.size() - 1);
    }
    
    public E pop(){
        if (list.isEmpty()) return null;
        return list.remove(list.size() - 1);
    } 


    public boolean isEmpty(){
        return list.size() == 0;
    }
}
        

class MyStack<E> {

    private val list: MyList<E?> = MyList<E?>()
    
    val isEmpty: Boolean
        get() = list.size == 0
    
    constructor(elements: Array<E?>) {
        for (i in elements.indices) {
            list.add(elements[i])
        }
    }

    constructor()
    
    fun push(e: E): Boolean {
        return list.add(e)
    }

    fun peek(): E? {
        if (list.isEmpty()) return null
        return list.get(list.size - 1)
    }

    fun pop(): E? {
        if (list.isEmpty()) return null
        return list.removeAt(list.size - 1)
    }

}
        

class MyStack {
    // Custom private-like list instance belonging to this stack
    list = new MyList();

    constructor(elements = null) {
        if (elements !== null) {
            for (let i = 0; i < elements.length; i++) {
                this.list.add(elements[i]);
            }
        }
    }

    push(e) {
        this.list.add(e);
        return true; // Returns a boolean matching the signature pattern
    }

    peek() {
        if (this.list.isEmpty()) return null;
        return this.list.get(this.list.getSize() - 1);
    }

    pop() {
        if (this.list.isEmpty()) return null;
        return this.list.remove(this.list.getSize() - 1);
    }

    isEmpty() {
        return this.list.getSize() === 0;
    }
}
        

class MyStack:

    def __init__(self, elements=None):
        self.list = MyList()
        if elements is not None:
            for i in range(len(elements)):
                self.list.add(elements[i])

    def push(self, e):
        self.list.add(e)
        return True

    def peek(self):
        if self.list.is_empty(): 
            return None
        return self.list.get(self.list.get_size() - 1)

    def pop(self):
        if self.list.isEmpty(): 
            return None
        return self.list.remove(self.list.get_size() - 1)

    def is_empty(self):
        return self.list.get_size() == 0
        

MyStack<Integer> stack = new MyStack();
stack.add(23);
stack.add(12);
stack.add(42);
stack.add(50);
stack.add(126);

while(!stack.isEmpty()){
   int number = stack.pop();
   System.out.println(number);
}
        

val stack: MyStack<Int> = MyStack()
stack.add(23)
stack.add(12)
stack.add(42)
stack.add(50)
stack.add(126)

while(!stack.isEmpty){
  val number = stack.pop();
  println(number);
}
        

let stack = new MyStack();
stack.push(23);
stack.push(12);
stack.push(42);
stack.push(50);
stack.push(126);

while (!stack.isEmpty()) {
    let number = stack.pop();
    console.log(number);
}      
        

stack = MyStack()
stack.push(23)
stack.push(12)
stack.push(42)
stack.push(50)
stack.push(126)

while not stack.is_empty():
    number = stack.pop()
    print(number)