单链表(Node)

简介

链表由多个结点组成，每个结点由两部分组成：

1. 本身的信息，称为“数据域”；
2. 指向直接后继的指针，称为“指针域”。

通过指针域将多个链表连接起来。

实现

public class OneNode<T> {

 private Node headNode;
 private int size;

 // 初始化
 public OneNode() {
    this.headNode = null;
    this.size = 0;
 }

 // 添加链表
 public void add(int index, T t) {
    if (index < 0 || index > size)
     throw new IllegalArgumentException("index is error");
    // 头部
    if (index == 0) {
	    // 如果链表不为空
	    if (headNode != null) {
	      headNode = new Node(t, headNode);
	    } else {
	      headNode = new Node(t, null);
	    }
	    size++;
    }
    // 尾部
    else if (index == size) {
      // 找到最后一位节点
      Node tempNode = headNode;
      //前一个结点
      Node startNode = null;
      for (int i = 0; i < size; i++) {
        startNode = tempNode;
        tempNode = tempNode.nextNode;
      }
      tempNode = new Node(t, null);
      startNode.nextNode = tempNode;
      size++;
   }
  // 中间
  else {
	  // 找到插入节点的前一位结点
	  Node tempNode = headNode;
	  for (int i = 0; i < index - 1; i ++) {
	    tempNode = tempNode.nextNode;
	  }
	  //找到插入节点的当前
	  Node tempCurrentNode = tempNode.nextNode;
	  tempNode.nextNode = new Node(t, tempCurrentNode);
	  size++;
	 }
 }
 
 //删除链表  找到删除结点的前后两个结点
 public void remove(int index){
  if (index < 0 || index > size)
   throw new IllegalArgumentException("index is error");
  //删除头结点
  if(index == 0){
     headNode.currentNode = headNode.nextNode.currentNode;
     headNode.nextNode = headNode.nextNode.nextNode;
  }
  //删除尾结点
  else if(index == size - 1){
     Node tempNode = headNode;
     for (int i = 0; i < index; i++) {
       tempNode = tempNode.nextNode;
     }
     tempNode = null;
  }
  //中间结点
  else{
    Node tempNode = headNode;
    Node startNode = headNode;
    Node endNode = null;
    //前结点
    for (int i = 0; i < index - 1; i++) {
     startNode = tempNode.nextNode;
    }
    //后结点
    endNode = startNode.nextNode.nextNode;
     //将前一个结点指向后一个结点
    startNode.nextNode = endNode;
  }
  size --;
 }

 //遍历链表
 public void show(){
   Node tempNode = headNode;
   for (int i = 0; i < size; i++) {
     System.out.print(tempNode.currentNode + " ");
     tempNode = tempNode.nextNode;
   }
 }
 
 private class Node {
   private T currentNode;
   private Node nextNode;

   public Node(T node, Node next) {
     this.currentNode = node;
     this.nextNode = next;
   }
 }
}

测试结果

public class Test {

 public static void main(String[] args) {
  OneNode oneNode = new OneNode();
  //新加结点
  System.out.println("***********新加结点**********");
  oneNode.add(0, "one");
  oneNode.add(1, "two");
  oneNode.add(2, "three");
  oneNode.add(3, "four");
  //在已经新加的结点添加
  oneNode.add(1, "five");
  oneNode.show();
  //移除中间的结点
  System.out.println("移除中间的结点");
  oneNode.remove(1);
  oneNode.show();
  //移除头部
  System.out.println("移除头部");
  oneNode.remove(0);
  oneNode.show();
  //移除尾部
  System.out.println("移除尾部");
  oneNode.remove(2);
  oneNode.show();
 }
}

**

总结

优点：添加删除比较方便，只需要改变指针的指向，没有固定的存储大小，可以无限扩大空间。
缺点：查找需要顺着指针一个个往下找，相比数组查找速度慢。