java实现单链表增删改查的实例代码详解

package 数据结构算法.链表;

/*
 *定义节点
 * 链表由节点构成
 */
public class node<e> {
  private e e;  //数据data
  private node<e> next; //指向下一个节点

  public node() {

  }

  public node(e e) {
    this.e = e;
  }

  public node<e> getnext() {
    return next;
  }

  public void setnext(node<e> next) {
    this.next = next;
  }

  public e gete() {
    return e;
  }

  public void sete(e e) {
    this.e = e;
  }
}

package 数据结构算法.链表;

/*
 * 定义实现类mylinkedlist
　*　实现链表的基本功能：增删改查
 */
public class mylinkedlist<e> {
  //声明头节点尾节点
  private node<e> head;
  private node<e> last;
  //链表的大小
  private int size;
  private int modcount; //计算被修改的次数

  public mylinkedlist() {
    head = new node<e>();//实例化头结点
    last = head;
  }

  /*
   *返回单链表中存储的元素总数
   */
  public int size() {
    return size;
  }

  /*
   *获取指定索引位置的节点对象
   */
  public node<e> get(int index) {
    if (index < 0 || index > size - 1)
      return null;
    node<e> node = head.getnext();//将头结点的下一个节点赋给node
    for (int i = 0; i < index; i++) {
      node = node.getnext();//获取node的下一个节点
    }
    return node;
  }

  /*
   *获取指定索引位置的数据
   */
  public e getvalue(int index) {
    if (index < 0 || index > size - 1)
      return null;
    node<e> node = get(index);
    return node.gete();
  }

  /*
   *增加元素
   */
  public void add(e e) {
    node<e> node = new node<e>(e); //以e实例化一个节点
    last.setnext(node);//往尾节点后追加节点
    last = node;//该节点设为最后一个节点
    size++;
    modcount++;
  }

  /*
   *指定位置插入元素,返回插入的节点数据
   */
  public e add(int index, e e) {
    if (index < 0 || index > size - 1)
      return null;
    node<e> node = new node<e>(e); //实例化一个节点
    //找到插入的原节点
    node<e> oldnode = get(index);
    if (index == 0) {//当索引为0时
      head.setnext(node);
    } else {
      //找到插入节点的上一个
      node<e> bnode = get(index - 1);
      bnode.setnext(node);
    }
    node.setnext(oldnode);
    size++;
    modcount++;
    return oldnode.gete();
  }

  /*
   *删除指定的节点e,并返回删除节点的数据
   */
  public e delete(int index) {
    if (index < 0 || index > size - 1)
      return null;
    if (index == 0) {//当索引为1，令头结点的下一个节点为头结点
      node<e> node = head.getnext();
      head.setnext(node.getnext());
    }
    //获取要删除节点的前一个节点
    node<e> bnode = get(index - 1);
    //获取要删除的节点
    node<e> node = bnode.getnext();
    //获取要删除节点的下一个节点
    node<e> nnode = node.getnext();
    //删除该节点
    bnode.setnext(nnode);
    //清除node的下一个节点
    node.setnext(null);
    size--;
    modcount++;
    return node.gete();//返回节点中的数据域
  }

  /*
   *修改指定位置的数据域并返回修改后的数据
   */
  public e set(int index, e e) {
    if (index < 0 || index > size - 1)
      return null;
    //获取指定位置的原节点
    node<e> node = get(index);
    node.sete(e);
    modcount++;
    return node.gete();
  }
}

package 数据结构算法.链表;

/*
 *定义测试类
 */
public class mylinkedlisttest {
  public static void main(string[] args) {
    mylinkedlist<string> list = new mylinkedlist<>();

    //测试add
    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");
    list.add(0,"newone");
    list.add(1,"newtwo");
    for (int i = 0; i < list.size(); i++) {
      system.out.print(list.getvalue(i)+" ");
    }

    //测试set
    system.out.println();
    list.set(0, "111");
    list.set(1, "222");
    system.out.println(list.getvalue(0) + "  " + list.getvalue(1));

    //测试delete
    system.out.println();
    list.delete(1);
    for (int i = 0; i < list.size(); i++) {
      system.out.print(list.getvalue(i)+" ");
    }
  }
}

运行结果如下：

 以上就是全部知识点内容，感谢大家对的支持。