Java中的链表

package com.coder.link;
 
import java.util.NoSuchElementException;
 
/**
 * 一个简单的泛型链表实现
 */
public class MyLinkedList {
 
    // 结点
    private class Node {
        Node next;     // 指向后继结点
        E data;            // 数据元素
        Node previous;  // 指向前驱结点
 
        public Node(Node next, E data, Node previous) {
            this.next = next;
            this.data = data;
            this.previous = previous;
        }
    }
 
    // 头结点
    private Node first;
 
    // 尾结点
    private Node last;
 
    // 有效元素个数
    private int size;
 
    /**
     * 默认构造函数
     */
    public MyLinkedList() {
    }
 
    public MyLinkedList(Node first, Node last, int size) {
        this.first = first;
        this.last = last;
        this.size = size;
    }
 
    /**
     * 将元素加到链表的尾部
     */
    public boolean add(E e) {
        Node l = last;               // 将尾结点赋值给l
        Node newNode = new Node<>(null, e, l);  // 新创建一个结点
        last = newNode;                // 将新创建的结点置成尾结点
 
        if (l == null) {
            first = newNode;           // 如果没有尾结点，则新创建的结点就是第一个结点
        } else {
            l.next = newNode;
        }
 
        size++;
        return true;
    }
 
    /**
     * 将元素插入到指定索引位置
     */
    public void add(int index, E e) {
        // 要在链表头部插入数据
        if (index == 0) {
            first = new Node<>(first, e, null);
        } else {
            // 获取上一个结点
            Node prev = node(index - 1);
            // 获取下一个结点
            Node next = prev.next;
            Node newNode = new Node<>(next, e, prev);
            prev.next = newNode;
        }
        size++;
    }
 
    private Node node(int index) {
        // 优化，判断查找的index和size的关系
        Node x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        return x;
    }
 
    /**
     * 获取指定索引位置的元素
     */
    public E get(int index) {
        return node(index).data;
    }
 
    /**
     * 获取链表的大小
     */
    public int size() {
        return size;
    }
 
    /**
     * 获取链表的头结点元素值
     */
    public E getFirst() {
        if (first == null) {
            throw new NoSuchElementException();
        }
        return first.data;
    }
 
    /**
     * 获取链表的尾结点元素值
     */
    public E getLast() {
        if (last == null) {
            throw new NoSuchElementException();
        }
        return last.data;
    }
 
    /**
     * 移除指定索引位置的元素
     */
    public E remove(int index) {
        Node node = first;
        if (index == 0) {
            first = node.next;
        } else {
            Node prev = node(index - 1);
            node = prev.next;
            prev.next = node.next;
        }
        size--;
        return node.data;
    }
}

这是一个Java类 MyLinkedList，它实现了一个简单的链表数据结构。以下是对这个类的代码和功能的分析：

1. 类结构：

• 这个类实现了一个泛型链表，可以存储任何类型的元素。
• 类中有一个内部私有类 Node，表示链表中的节点，包括数据元素 data、指向下一个节点的引用 next，以及指向前一个节点的引用 previous。

1. 成员变量：

   • first: 表示链表的头结点。
   • last: 表示链表的尾结点。
   • size: 表示链表中有效元素的个数。

2. 构造函数：

• 类有两个构造函数，一个是默认构造函数，另一个接受头结点、尾结点和有效元素个数的参数。

1. 添加元素：

   • add(E e): 将元素加到链表的尾部，创建一个新的节点并将其链接到尾部。
   • add(int index, E e): 将元素插入到指定索引位置，根据索引找到前一个节点和后一个节点，然后插入新节点。

2. 获取元素：

   • get(int index): 获取指定索引位置的元素。
   • getFirst(): 获取链表的头结点元素。
   • getLast(): 获取链表的尾结点元素。

3. 移除元素：

   • remove(int index): 移除指定索引位置的元素，根据索引找到前一个节点和待删除节点，然后移除。

这个类实现了一个简单的链表数据结构，提供了基本的添加、获取和移除元素的功能。它可以用于存储任何类型的数据，但在实际使用中，可能需要进一步扩展以满足特定的需求。此外，注释中提到了一些与 LinkedList 相关的内容，但这些内容不在这个类的代码中。

3.LinkedList