单向链表的增删改查

链表节点类

public class Node<E> {
    private E data;
    private Node<E> next;

    public Node() {}

    public Node(E data) {this.data = data;}

    public E getData() {return data;}

    public void setData(E data) {this.data = data;}

    public Node<E> getNext() {return next;}

    public void setNext(Node<E> next) { this.next = next;}
    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

链表的增删改查方法

package com.node;

public class SingleChainLIst<E> {
    //先定义头节点和尾节点
    private Node<E> head;
    private Node<E> last;
    //链表的大小和被修改的次数,默认值是0
    private int size;
    private int modifiyCount;
    
//构造的时候初始化头和尾节点
    public SingleChainLIst() {
        head=new Node<E>();
        last=head;
    }
    public int getSize(){
        return size;
    }
    public Node<E> getHead(){
        return head;
    }
    public Node<E> getLast(){
        return last;
    }
    //查询指定节点
    public Node<E> getNode(int index){
        if(index<1||index>size){
            return null;
        }
        //获取头节点的下一个节点，真正的第一个节点
        Node<E> node = head.getNext();
        for (int i = 1; i <index ; i++) {
           node= node.getNext();
        }
        return node;
    }
    //获取指定节点的值
  public E getValue(int index){
      if(index<1||index>size){
          return null;
      }
      Node<E> node = getNode(index);
      E data = node.getData();
      return data;
  }
  //链表末尾增加节点
  public void addNode(E e){
        Node<E> node=new Node<>(e);
        last.setNext(node);
        last=node;
        size++;
        modifiyCount++;
  }
  //指定位置增加节点，当前节点向后移动，并返回当前向后移动节点的数据
  public E addNode(int index,E e){
        if(index<1||index>size){
            return null;
        }
        Node<E> newNode=new Node<>(e);
      Node<E> oldNode = getNode(index);
     if(index==1){
         head.setNext(newNode);
     }else{
         Node<E> preNode = getNode(index - 1);
         preNode.setNext(newNode);
     }
     newNode.setNext(oldNode);
     size++;
     modifiyCount++;
     return oldNode.getData();
  }
  //删除节点
  public E delete(int index){
        if(index<1||index>size){
            return null;
        }
      Node<E> currentNode;
        if(index==1){
            //如果是1，得到真正的第一个节点
            currentNode = head.getNext();
            //通过第一个节点去获得第二个节点，覆盖第一个节点
            head.setNext(currentNode.getNext());
            currentNode.setNext(null);
        }else{
            //获得当前节点，当前节点的前一个节点，当前节点的下一个节点
            Node<E> preNode = getNode(index - 1);
            currentNode=getNode(index);
            Node<E> nextNode = currentNode.getNext();
            //当前节点的上一个节点pre的下一个节点，为当前节点的下一个节点
            preNode.setNext(nextNode);
            //当前节点的下一个节点置空
            currentNode.setNext(null);
        }
      size--;
      modifiyCount++;
      return currentNode.getData();
  }
  //更新指定节点的数据
  public E updateNode(int index,E e){
        if(index<1||index>size){
            return null;
        }
      Node<E> node = getNode(index);
        node.setData(e);
        modifiyCount++;
        return node.getData();
  }
}

测试

public class TestChainList {
    public static void main(String[] args) {
        SingleChainLIst<String> chainLIst=new SingleChainLIst<>();
       chainLIst.addNode("one");
       chainLIst.addNode("two");
       chainLIst.addNode("three");
       chainLIst.addNode("four");
       chainLIst.addNode("five");
    }
}