【java版数据结构】单链表的设计与实现

介绍:
链表是一种物理存储单元上非连续，非顺序的存储结构，其物理结构不能表示元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点组成，并且每个结点在运行时动态生成。

而单链表，顾名思义是单方向的链表,本文章实现的单链表包括一个头结点head，一个记录链表长度的N,以及若干个数据结点，数据结点由一个数据域ite,和一个指向下一个结点的指针域next组成。
头结点是链表的入口，链表第一个存储的数据元素，我们规定下标为0；

在java中，一切皆对象，所以我们单链表的实现也可构造一个类，LinkList
而链表内部的结点也是一个对象，我们可通过内部类去实现它

单链表三个的成员变量

结点类的实现

//单链表的成员内部类,表示链表中的每个节点
    //泛型T表示节点存储的数据类型是任意的
    //指针域表示当前节点的下一个节点
    private class Node{
        //数据域
        T item;
        //指针域
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

单链表的构造方法

初始化头结点（数据域为空，因为不指向任何一个元素，所以指针域也为空）和链表长度

    //链表的构造方法
    public LinkList() {
        //初始化头结点
        this.head = new Node(null,null);
        //初始化链表长度
        this.N=0;
    }

在链表尾部添加元素

只需要将原先的尾部结点指向新结点，并将新结点指针域置空

    //往线性表中添加一个元素
    public  void insert(T item){
        Node node=head;
        //找到最后一个节点
        while(node.next!=null){
            node=node.next;
        }
        //创建新节点
        Node newNode=new Node(item,null);
        //添加新节点
        node.next=newNode;
        //链表长度加一
        N++;
    }

在链表的指定下标处添加元素

先找到指定下标的前一个元素pre,再找到指定下标的结点curr，将pre指向新结点，新结点指向curr结点

 //在线性表的i索引处插入一个值为item的数据元素
    public void insert(int i,T item){
        Node pre=head;
        //找到位置i之前的节点,从头结点开始遍历
        for (int index = 0; index <=i-1 ; index++) {
            pre= pre.next;
        }
        //找到i索引处的结点
        Node curr=pre.next;
        //新建一个结点，并指向当前结点
        Node newNode=new Node(item,curr);
        //上一个结点指向新结点
        pre.next=newNode;
        //元素个数+1
        N++;
    }

获取指定下标位置的元素

从索引0开始遍历，一直遍历到指定的下标i，每次遍历指针都往后移动一位

//读取并返回线性表中指定位置元素的值
    //链表下标从0开始，不包括头结点
    public  T get(int i){

        Node n=head;
        //找到位置为i的元素
        for(int index=0;index<=i;index++){
            n=n.next;
        }
        return n.item;
    }

删除指定下标位置的元素，并返回元素的值

和在指定位置插入类似，先找到指定下标的前一个元素pre，再找到指定下标的结点curr,再找到指定下标的下一个元素next
将pre直接指向next,跳过curr，即可完成删除

//删除并返回线性表中索引为i的数据元素
    public T remove(int i){
        //找到位置i之前的节点,从头结点开始遍历
        Node pre=head;
        for (int index = 0; index<=i-1; index++) {
            pre=pre.next;
        }
        //找到当前元素
        Node curr=pre.next;
        //前一个元素指向后一个元素
        pre.next=curr.next;
        //长度-1
        N--;
        return curr.item;
    }

返回元素在链表首次出现的位置

从0下标开始遍历查找，直到遍历完整个链表

  //返回线性表中首次出现指定的数据元素的位序号，若不存在，则返回-1
    public  int indexOf(T item){
        Node node=head;
        for(int i=0;node.next!=null;i++){
            node=node.next;
            if(node.item.equals(item)){
                return i;
            }
        }
        return -1;
    }

单链表的遍历

我们可以学习集合ArrayList的forEach遍历方法，去实现Iterator迭代器
我们通过链表类去实现Iterable接口，重写Iterable的Iterator方法，实现迭代器，由于Iterator方法的返回值是接口类型的Iterator,所以我们还创建了一个内部类去实现这个Iterator接口，以实现Iterator的类的对象返回

 @Override
    public Iterator<T> iterator() {
        //用内部类实现Iterator接口
        return new LIterator();
    }

    //内部类
    private class LIterator implements Iterator{
        private Node node;
        public LIterator(){
            this.node=head;
        }
        @Override
        public boolean hasNext() {
            return node.next!=null;
        }

        @Override
        public Object next() {
            node=node.next;
            return node.item;
        }
    }