数据结构与算法-自定义单向链表API

类名	MyLinkedList
构造方法名	public MyLinkedList()
成员内部类	public class Node；结点类
成员方法	public void insert(T t) ；往线性表添加一个元素 public void insert(int i,T t)；在指定位置添加一个元素 public void clear()；清空整个线性表； public int length()；获取线性表数据个数（长度） public T remove(int index)；删除指定索引处元素，并将其返回 public int indexOf(T t)；获取该元素第一次出现的位序号 public boolean isEmpty()；判断线性表是否为空 public T get(int index)；获取线性表中指定位序号处的值
成员变量	private int size；记录当前线性表的元素个数 private Node head;；定义头结点
成员内部类变量	private T item；用于存储数据 private Node next;用于存储下一个结点信息

代码如下

输出结果

闲言
csdn_闲言
鸡哥
鸡哥
闲言博客
记录成长，记录学习
记录成长，记录学习
====================
链表长度是：7
鸡哥第一次出现的位置是：2
记录成长，记录学习第一次出现的位置是：5
删除1处的元素是：csdn_闲言
删除2处的元素是：鸡哥
链表长度是：5
链表0处元素是：闲言
链表1处元素是：鸡哥
链表2处元素是：闲言博客
链表长度是：0
判断链表是否为空：true

测试类

public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        list.insert("闲言");
        list.insert("鸡哥");
        list.insert("鸡哥");
        list.insert("闲言博客");
        list.insert("记录成长，记录学习");
        list.insert("记录成长，记录学习");
        //在指定位置添加元素
        list.insert(1, "csdn_闲言");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("====================");
        System.out.println("链表长度是：" + list.length());
        System.out.println("鸡哥第一次出现的位置是：" + list.indexOf("鸡哥"));
        System.out.println("记录成长，记录学习第一次出现的位置是：" + list.indexOf("记录成长，记录学习"));

        //删除指定位置索引
        System.out.println("删除1处的元素是：" + list.remove(1));
        System.out.println("删除2处的元素是：" + list.remove(2));

        System.out.println("链表长度是：" + list.length());
        System.out.println("链表0处元素是：" + list.get(0));
        System.out.println("链表1处元素是：" + list.get(1));
        System.out.println("链表2处元素是：" + list.get(2));
        //置空链表
        list.clear();
        System.out.println("链表长度是：" + list.length());
        System.out.println("判断链表是否为空：" + list.isEmpty());

    }

MyLinkedList类

package cn.bloghut.linear;



import java.util.Iterator;

/**
 * @author by 闲言
 * @classname MyLinkedList
 * @description TODO
 * @date 2021/7/16 10:36
 */
public class MyLinkedList<T> implements Iterable<T> {
    //定义头结点
    private Node head;
    //存储线性表长度
    private int size;


    public class Node {
        //用于存储数据
        private T item;
        //用于存储下一个结点信息
        private Node next;

        //初始化数据
        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    //初始化数据
    public MyLinkedList() {
        //初始化头结点-头结点不是用来存储数据的，也还没有指向下一个结点
        head = new Node(null, null);
        //初始化元素个数
        size = 0;
    }

    /**
     * 清空线性表
     */
    public void clear() {
        //长度置为空
        size = 0;
        //头结点没有指向
        head.next = null;
    }

    /**
     * 判断是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取线性表中元素个数
     *
     * @return
     */
    public int length() {
        return size;
    }

    /**
     * 返回指定索引处元素
     *
     * @param index
     * @return
     */
    public T get(int index) {
        //记录头结点
        Node node = head;
        //通过循环从头结点开始往后找，依次找i次，就可以找到对应的元素
        for (int i = 0; i <= index; i++) {
            node = node.next;
        }
        return node.item;
    }

    /**
     * 往线性表中添加元素
     *
     * @param t
     */
    public void insert(T t) {
        Node node = head;
        //找到当前最后一个结点
        while (node.next != null) {
            //最后一个结点的next属性是为null的
            node = node.next;
        }
        //创建新结点，保存元素
        node.next = new Node(t, null);
        //元素个数+1
        size++;
    }

    /**
     * 在i索引处添加t值
     *
     * @param i
     * @param t
     */
    public void insert(int i, T t) {
        //创建新结点
        Node newNode = new Node(t, null);
        //找到i处的前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        //找到i处的结点
        Node oldNode = pre.next;
        //让i处的前一个结点指向新的结点
        pre.next = newNode;
        //让新的结点指向旧i处的结点
        newNode.next = oldNode;
        //线性表个数自增1
        size++;
    }

    /**
     * 删除指定索引处元素
     *
     * @param i
     * @return
     */
    public T remove(int i) {
        //从头结点开始找,找到i前一个结点
        Node node = head;
        for (int index = 0; index < i; index++) {
            node = node.next;
        }
        //获取要删除的i位置的结点
        Node temp = node.next;
        //让i前一个结点指向 要删除结点的后一个结点
        node.next = temp.next;
        //链表长度减1
        size--;
        //将删除的元素返回
        return temp.item;
    }

    /**
     * 获取元素t 第一次出现的索引位置
     * @param t
     * @return
     */
    public int indexOf(T t) {
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.item.equals(t)) {
                return i;
            }
        }
        return -1;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    /**
     * 自定义迭代器
     */
    public class MyIterator implements Iterator {

        private Node n;
        //初始化数据
        public MyIterator() {
            n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            //指针往后移动
            n = n.next;
            return n.item;
        }
    }

}