java实现链表

1. 链表的概念：链表是一种在物理上非连续、非顺序的数据结构，由若干节点组成。链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。

2. 常见的链表包括：单链表、双向链表、循环链表

3. 存储原理：数组在内存中的存储方式是顺序存储（连续存储），链表在内存中的存储方式是随机存储（链式存储）。链表的每一个节点分布在内存中不同的位置，依靠next指针关联起来。这样就可以灵活的利用零散的碎片空间。

4. 时间复杂度：查找某一个节点：O(n)

   ​ 删除某一个节点：O(1)

   ​ 添加某一个节点：O(1)

   ​ 修改某一个节点：O(1)

5. 代码实现

   ---

   public class LinkedListNode<T> {
       public T data;
       public LinkedListNode<T> next;
   
       public LinkedListNode(T data) {
           this.data = data;
       }
   }
   

   public class LinkedList<E> {
       //头节点
       private LinkedListNode<E> head;
       //尾节点
       private LinkedListNode<E> tail;
   
       private int size = 0;
   
   
       /**
        * 添加节点
        * @param e 要添加的节点数据
        */
       public void addNode(E e){
          final LinkedListNode<E> temp = tail;
          final LinkedListNode<E> newNode = new LinkedListNode<>(e);
          tail = newNode;
           if (temp == null){
               head = newNode;
           }else {
               temp.next = newNode;
           }
           size++;
       }
   
   
       /**
        * 获取节点数据
        * @param index 下标
        * @return 节点数据
        */
       public E get(int index){
           checkIndex(index);
           LinkedListNode<E> temp = head;
           if (temp.next == null){
               return temp.data;
           }
           int i = 0;
           while (i < index){
               temp = temp.next;
               i++;
           }
           return temp.data;
       }
   
       /**
        * 获取链表中所有的数据
        */
       public void showList(){
           if (head == null){
               throw new NullPointerException("The linked list is null");
           }
           if (head.next == null){
               System.out.println(head.data);
               return;
           }
           LinkedListNode<E> node = head;
           while (true){
               System.out.println(node.data);
               if (node.next == null){
                   return;
               }
               node = node.next;
           }
       }
   
       /**
        * 根据链表中的元素值删除链表中的元素
        * @param o 元素
        * @return true 删除成功, false 删除失败
        */
       public boolean remove(Object o){
           if (o == null){
               for (LinkedListNode<E> x = head; x != null; x = x.next){
                   if (x.data == null){
                       unlink(x);
                       return true;
                   }
               }
           }else{
               for (LinkedListNode<E> x = head; x != null; x = x.next){
                   if (o.equals(x.data)){
                       unlink(x);
                       return true;
                   }
               }
           }
           return false;
       }
   
       /**
        * 根据索引删除元素
        * @param index 索引
        * @return true-->删除成功 false-->删除失败
        */
       public boolean remove(int index){
           checkIndex(index);
           LinkedListNode<E> temp = head;
           int i = 0;
           while (i < size) {
               if (i == index) {
                   unlink(temp);
                   return true;
               }
               temp = temp.next;
               i++;
           }
           return false;
       }
   
       private void checkIndex(int index){
           if (index > size-1 || index <0){
               throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
           }
       }
       private void unlink(LinkedListNode<E> x){
           final E element = x.data;
           LinkedListNode<E> temp = head;
           while (true){
               if (temp.next == null){
                   throw new RuntimeException("The target element does not exit");
               }
               // 要移除的元素为null时
               if ( element == null && temp.next.data == null){
                   temp.next = temp.next.next;
                   break;
               }
               // 要移除的元素不为null时
               if (element != null && element.equals(temp.next.data)){
                   temp.next = temp.next.next;
                   break;
               }
               temp = temp.next;
           }
           size--;
           x.data = null;
       }
       
       //测试
       public static void main(String[] args) {
           LinkedList<String> l = new LinkedList<>();
           l.addNode("s");
           l.addNode("dewie");
           l.addNode("er");
           l.addNode(null);
           l.addNode("des");
           l.addNode("dsf");
           l.addNode("d发");
           l.addNode("safa但是vri");
           boolean remove = l.remove(8);
           if (remove){
               l.addNode("哈哈");
           }
   
           System.out.println(l.get(3));
   
   //        for (int i = 0; i < l.size; i++) {
   //            System.out.println(l.get(i));
   //        }
       }
   }