Singly linked list implementation (Java | swift)

Java Implementation

Public class SingleLinkList<E> {private int size; Private Node<E> first; static final int ELEMENT_NOT_FOUND = -1; private static class Node<E> { E element; Node<E> next; public Node(E element, Node<E> next) { this.element = element; this.next = next; }} /** * empty */ public voidclear() {
        first = null;
        size = 0;
    }

    /**
     * 是否为空
     */
    public boolean isEmpty() {
        return first == null;
    }

    public int size() {
        return size;
    }

    /**
     * get
     * @param index
     * @return
     */
    public E get(int index) {
        returnnode(index).element; } / * * *setReturn old value * @param index * @param element */ public Eset(int index, E element) {
        Node<E> node = node(index);
        E oldElement = node.element;
        node.element = element;
        returnoldElement; } public void add(int index, E element) {rangeCheckForAdd(index);if (index == 0) {
            first = new Node<E>(element, first);
        } else{ Node<E> pre = node(index-1); pre.next = new Node<E>(element, pre.next); } size++; } /** * public E remove(int index) {rangeCheck(index); Node<E> node = first;if (index == 0) {
            first = first.next;
        } else {
            Node<E> pre = node(index-1);
            node = pre.next;
            pre.next = node.next;
         }
        size --;
        returnnode.element; } /** * public int indexOf(E element) {if (element == null) {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (node.element == null) returni; node = node.next; }}else {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) returni; node = node.next; }}returnELEMENT_NOT_FOUND; Private Node<E> Node (int index) {rangeCheck(index); private Node<E> Node (int index) {rangeCheck(index); Node<E> node = first;for (int i = 0; i < index; i++) {
            node = node.next;
        }
        returnnode; } /** * check index */ private void rangeCheck(int index) {if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }

    private void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }

    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

    @Override
    public String toString() {

        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append("[");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if(i ! = 0) string.append(",");
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        returnstring.toString(); }}Copy the code

Swift

import Foundation class Node<E> { var element: E var next: Node? init(element: E, next: Node?) {self.element = element self.next = next}} struct SingleLinkList<E: Comparable> {private var size: Int? Private var first: Node<E>?let ELEMENT_NOT_FOUND: Int = -1
    
    var isEmpty: Bool {
        return first == nil
    }
    
    /**
     get
     */
    public func get(index: Int) -> E {
        return node(index: index).element
    }
    
    /**
     set
     */
    public func set(index: Int, newElement: E) -> E {
        let currNode = node(index: index)
        let oldElement: E = currNode.element
        currNode.element = newElement
        returnOldElement} /** empty */ mutating public funcclear() {first = nil size = 0} /** add element */ mutating public add(index: Int, newElement: E) {rangCheckForAdd(index: Int, newElement: E) {rangCheckForAdd(index: Int, newElement: E) index)if index == 0 {
            first = Node(element: newElement, next: first)
        } else {
            letpre = node(index: index-1) pre.next = Node(element: newElement, next: pre.next) } size = (size ?? */ mutating public func remove(index: Int) -> E {rangCheck(index: index)let currNode = first!
        if index == 0 {
            first = currNode.next
        } else {
            let preNode = node(index: index-1)
            lettempNode = preNode.next preNode.next = tempNode! .next } size = size! - 1returnPublic func indexOf(element: E) -> Int {var curNode = first; public func indexOf(element: E) -> Int {var curNode = first; var i = 0while i < size! {
            ifcurNode? .element == element {returni } curNode = curNode? .next i = i + 1 }returnELEMENT_NOT_FOUND} /** Private func node(index: Int) -> node <E> {rangCheck(index: index) var node = first; var i: Int = 0whilei < index { node = node? .next i = i + 1 }return node!
    }
    
    private func rangCheck(index: Int) {
        if index < 0 || index >= size! {
            outOfBounds(index: index)
        }
    }
    
    private func rangCheckForAdd(index: Int) {
        if index < 0 || index > size ?? 0 {
            outOfBounds(index: index)
        }
    }
    
    private func outOfBounds(index: Int) {
        print("Index: \(index) , Size = \(String(describing: size))")}}Copy the code