java实现单链表的插入、删除与反转

单链表结构如下:

import java.util.NoSuchElementException;

public class MyLinkedList<T> {
    private int size;
    private Node<T> first;
    private Node<T> last;

    public boolean add(T t) {
        return addLast(t);
    }

    private boolean addLast(T t) {
        Node<T> newNode=new Node<>(t,null);
        Node<T> l=last;
        last=newNode;
        if (l==null) {
            first=newNode;
        }else {
            l.next=newNode;
        }
        size++;
        return true;
    }

    public boolean addFirst(T t){
        Node<T> newNode=new Node<>(t,null);
        Node<T> l=first;
        first=newNode;
        if (l==null) {
            last=newNode;
        }else {
            first.next=l;
        }
        size++;
        return true;
    }

    public boolean add(int index,T t){
        checkIndex(index);
        if (index==0) {
            addFirst(t);
        }else if(index==size){
            addLast(t);
        }else {
            addBefore(t,node(index));
        }
        return true;
    }

    public void addBefore(T t,Node<T> targetNode){
        Node<T> newNode=new Node<>(t,targetNode.next);
        targetNode.next=newNode;
        size++;
    }

    private Node<T> node(int index) {
        Node<T> x=first;
        for (int i = 0; i < index; i++) {
            x=x.next;
        }
        return x;
    }

    public T removeFirst(){
        if (first==null) {
            throw new NoSuchElementException();
        }
        Node<T> newFirst=first.next;
        T item=first.item;
        first.item=null;
        first.next=null;
        first=newFirst;
        size--;
        return item;
    }

    public T removeLast(){
        if (last==null) {
            throw new NoSuchElementException();
        }
        size--;
        Node<T> lastNode=last;
        if (last==first) {
            last=null;
            first=null;
        }else {
            Node<T> tmp=first;
            for (int i = 0; i < size - 1; i++) {
                tmp=tmp.next;
            }
            tmp.next=null;
            last=tmp;
        }
        T t=lastNode.item;
        lastNode.next=null;
        lastNode.item=null;
        return t;
    }

    public T remove(int index){
        checkIndex(index);
        Node<T> preNode=node(index-1);
        Node<T> removeTarget=preNode.next;
        preNode.next=removeTarget.next;
        T t=removeTarget.item;
        removeTarget.next=null;
        removeTarget.item=null;
        removeTarget=null;
        size--;
        return t;
    }

    public boolean remove(T t){
        if (size==0) {
            return false;
        }
        Node<T> tmp=first;
        if (t.equals(tmp.item)) {
            removeFirst();
        }else if(t.equals(last.item)){
            removeLast();
        }else {
            tmp=tmp.next;
            for (int i = 0; i < size; i++) {
                if(t.equals(tmp.item)){
                    remove(i);
                    return true;
                }
                tmp=tmp.next;
            }
        }
        return false;
    }


    private void checkIndex(int index) {
        if (!(index>=0 && index<=size)) {
           throw new IndexOutOfBoundsException();
        }
    }

    public void reverse() {
        if (size==0) {
            return;
        }
        Node<T> pre=null;
        Node<T> next=null;
        Node<T> tmp=first;
        first=last;
        last=tmp;
        //遍历链表,逐步取出链表并颠倒链表顺序
        while (tmp!=null){
            next=tmp.next;
            tmp.next=pre;
            pre=tmp;
            tmp=next;
        }
    }

    private class Node<T> {
        T item;
        Node<T> next;

        public Node(T item, Node<T> next) {
            this.item = item;
            this.next = next;
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder(size+2);
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(i==size-1?node(i).item:node(i).item+",");
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

调用代码

        MyLinkedList<String> strList = new MyLinkedList<>();
        strList.add(0,"3");
        strList.add("4");
        strList.add("7");
        strList.remove("7");
        strList.addFirst("2");
        System.out.println("原链表："+strList+"\n");
        strList.reverse();
        System.out.println("反转后的链表："+strList);

日志打印：

原链表：[2,3,4]

反转后的链表：[4,3,2]

参考

Java实现单链表插入、删除、遍历、反转