لیست پیوندی (LinkedList) در برنامه نویسی

function get(index: int): E {
  
  if index < 0 or index > size - 1
     throw IndexOutOfBoundException

     count := 0
     node := firstNode

     while count != index
         node := node.next

    return node.element
}
        

public class MyLinkedList<E> {

    private Node<E> firstNode;
    private Node<E> lastNode;

    private int size;


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

    public int getSize() {
        return size;
    }

    public void addFirst(E element){

        Node<E> newNode = new Node<>(element, null, null);

        if (isEmpty()){
            firstNode = newNode;
            lastNode = newNode;
        }else{
            firstNode.prev = newNode;
            newNode.next = firstNode;
            firstNode = newNode;
        }

        size++;
    }

    public void addLast(E element){
        Node<E> newNode = new Node<>(element, null, null);

        if (isEmpty()){
            firstNode = newNode;
            lastNode = newNode;
        }else {
            lastNode.next = newNode;
            newNode.prev = lastNode;
            lastNode = newNode;
        }

        size++;
    }

    public E getFirst(){
        if(isEmpty()) throw NoSuchElementException("The LinkedList is empty");

        return firstNode.element;
    }

    public E getLast(){
        if(isEmpty()) throw NoSuchElementException("The LinkedList is empty");

        return lastNode.element;
    }

    public E get(int index){
        if (index < 0 || index > size - 1)
            throw new IndexOutOfBoundsException("The index should be between 0 and " + (size -1));

        Node<E> node;

        if (size == 1){
            node = firstNode;
        }else {
            int count = 0;
            Node<E> currentNode = firstNode;
            while (count != index){
                currentNode = currentNode.next;
                count++;
            }

            node = currentNode;
        }

        return node.element;
    }

    public E removeFirst(){

        if (isEmpty())
            throw new NoSuchElementException("The list is empty");

        Node<E> removedNode;

        if (size == 1){
            removedNode = firstNode;
            firstNode = null;
            lastNode = null;
        }else {
            removedNode = firstNode;
            firstNode = firstNode.next;
            firstNode.prev = null;
        }

        size--;
        return removedNode.element;
    }


    public E add(int index, E element){
        //TODO Left as an exercise

        return null;
    }

    public E remove(int index){
        //TODO Left as an exercise

        return null;
    }

    public E removeLast(){
        //TODO Left as an exercise

        return null;
    }

    private static final class Node<E> {
        private final E element;
        private Node<E> next;
        private Node<E> prev;

        Node(E element, Node<E> next, Node<E> prev) {
            this.element = element;
            this.next = next;
            this.prev = prev;
        }

    }
}
        

class MyLinkedList<E> {

    private var firstNode: Node<E>? = null
    private var lastNode: Node<E>? = null
    var size = 0

    val  empty get() = size == 0

    fun addFirst(element: E){

        val newNode: Node<E> = Node(element)

        if (size == 0) {
            firstNode = newNode
            lastNode = newNode
        }else{
            newNode.next = firstNode
            firstNode!!.prev = newNode
            firstNode = newNode
        }

        size++
    }


    fun addLast(element: E){
        if (size == 0){
            firstNode = Node(element)
            lastNode = Node(element)
        }else{
            val node = Node(element)
            node.prev = lastNode
            lastNode!!.next = node
            lastNode = node
        }

        size++
    }

    fun getFirst(): E?{
        return firstNode?.element
    }


    fun getLast(): E?{
        return lastNode?.element
    }


    fun get(index: Int): E? {

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

        if (empty)
            throw NoSuchElementException("The List is empty")

        var node: Node<E>?

        var count = 0

        var currentNode = firstNode

        while (count != index ){
            currentNode = currentNode?.next
            count++
        }

        node = currentNode

        return node?.element
    }

    fun removeFirst(): E {

        if (empty)
            throw NoSuchElementException("There's no element in list")

        val node: Node<E>

        if (size == 1) {
            node = firstNode!!
            firstNode = null
            lastNode = null
        } else{
            node = firstNode!!
            firstNode = firstNode!!.next
            firstNode!!.prev = null
        }

        size--

        return node.element
    }

    fun add(index: Int, element: E){
        //TODO left as an exercise
    }

    fun removeLast(): E? {
        //TODO left as an exercise
        return null
    }

    fun remove(index: Int): E?{
        //TODO left as an exercise
        return null
    }
    
   private data class Node<E>(val element: E, var next: Node<E>? = null, var prev: Node<E>? = null)
}
        

LinkedList<String> colors = new LinkedList<>();
colors.add("Blue");
colors.add("Pink");
colors.add("Purple");
colors.addFirst("Cyan");
colors.add(1, "Red");
colors.removeLast();
colors.addLast("Yellow");

System.out.println("Display colors ");
for(int i =0; i<colors.size(); i++){
  String c = colors.get(i);
  System.out.print(c + " ");
}

System.out.println("Remove and Display colors backward: ");

while(!colors.isEmpty()){
  String c = colors.removeLast();
  System.out.println(c);
  
}
        

val colors: LinkedList<String> = LinkedList<>();
colors.add("Blue")
colors.add("Pink")
colors.add("Purple")
colors.addFirst("Cyan")
colors.add(1, "Red")
colors.removeLast()
colors.addLast("Yellow")

System.out.println("Display colors ");
for(i in 0 until colors.size ){
  val c = colors.get(i)
  print("$c ")
}

println("Remove and Display colors backward: ")

while(!colors.isEmpty()){
  val c = colors.removeLast()
  println(c)
}