نگاهی به لیست (List) در برنامه نویسی

function add(element: E){
  
  if size = capacity
     
     array := new E[(capacity *= 2)]
     
     for 0 <= i < elements.length i++
       array[i] := elements[i]

     array[size++] = element
     elements = array

  else
     elements[size++] = element

}
        

function get(index: int): E {  

   if index < 0 or index >= size
    throw IndexOutOfBoundsException

   if size = 0
     throw NoSuchElementException

  return elements[index];
}
        

for 0 <= i < list.size i++
  e := list.get(i);
  print(e);
        

function remove(index: int): E {
  if index < 0 or index >= size
    throw IndexOutOfBoundsException

  if size = 0
    throw NoSuchElementException

  removedElement := elements[index]
  elements[index] := null

  if index < size - 1
    array := E[capacity]
    count := 0
    for 0 <= i < size i++
      if elements[i] != null
        array[count++] := elements[i]

    elements = array

  size--
}
        

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
    }

}