Java实现链表

data是数据域

next是指针域

头节点：不存储数据，是链表的入口

链表不是数组，所以没有索引
头节点不算链表长度，
也是从0开始计数，第0个节点就是头节点的下一个节点
或者也可以叫第1个节点

java实现定义节点类代码

package StructDate;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 从南到北
 * @Date: 12/09/2021/15:39
 * @Description:
 *  泛型，数据结构，java实现链表
 */
public class Node<T> {
    //存储元素
    public T item;
    //创建本类对象，用于指向下一个节点
    public Node next;

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

    public static void main(String[] args) {
        //构建节点，设置每一个节点的后一个节点都是空
        Node<Integer> a = new Node<>(11, null);
        Node<Integer> b = new Node<>(12, null);
        Node<Integer> c = new Node<>(13, null);
        Node<Integer> d = new Node<>(14, null);
        Node<Integer> e = new Node<>(15, null);

        //生成链表,node也是数据结构的一种，当是int ，string其中的一种
        a.next = b;
        b.next = c;
        c.next = d;
        d.next = e;
        
    }
}

运行成功，没有内容是因为我们没有输出

java实现链表节点和定义链表方法

1. 定义节点类 【内部类】
2. 初始化链表（头结点和链表长度）
3. 清空链表
4. 获取链表长度
5. 判断链表是否为空
6. 获取指定i处的元素
7. 在链表中添加元素t
8. 在链表指定位置i处添加元素t
9. 删除指定位置i处的元素，并返回被删除的元素
10. 查找元素t在链表中第一次出现的位置

package algorithm.linear;


import java.util.Iterator;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 从南到北
 * @Date: 12/03/2021/20:03
 * @Description:  java链表的增删改查
 */
public class LinkList<T>  implements Iterable<T> {

        //记录头节点
        private Node head;
        //记录链表长度
        private int N;

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

    //定义一个内部类,作为节点类

        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 clear(){

            head.next = null;
            this.N=0;

        }

        //获取链表长度
        public int length(){
            //只需要返回节点个数即可
            return N;
        }

        //判断链表是否为空
        public boolean isEmpty(){
            //只要节点个数为0即可
            return N==0;
        }

        //获取指定位置i处的元素
        //在数组中，直接根据索引即可返回，
        //但是在链表中，就要顺序查找，从头结点开始查找

       // 6.  获取指定i处的元素
    public T get(int i){
        //通过循环，从头结点开始往后找，就可以找到对应的元素
        Node n=head.next;
        for (int index=0;index<i;index++){
            n=n.next;
        }
        return n.item;
    }

        //向链表中添加元素t
        public void insert(T t){
            //找到当前最后一个节点

            Node n = head;
//          当节点不为空，那么就让节点一直

            while(n.next!=null){

                n=n.next;   //也就是说，节点n的值不断后移

            }

            //创建新节点，保存元素t
            Node newNode = new Node(t,null);
            //让当前最后一个节点指向新节点
            n.next = newNode;
            //元素的个数+1
            N++;
        }

        
//        -----

        //向指定位置i出，添加元素t
        public void insert(int i,T t){

            //找到i位置前一个节点,
            Node pre = head;
            //在i处添加，而不是在第i个位置添加
            for (int index=0;index<i;index++){
                pre=pre.next;
            }
            //找到i位置的节点
            Node curr = pre.next;
            //创建新节点，并且新节点需要指向原来i位置的节点
            Node newNode = new Node(t, curr);
            //原来i位置的前一个节点指向新节点即可
            pre.next = newNode;
            //元素个数+1
            N++;
        }

        //删除指定位置i处，并返回被删除的元素
        public T remove(int i){
            //找到i位置的前一个节点
            Node pre = head;
            for (int index = 0;index<=i;i++){
                pre = pre.next;
            }
            //要找到i位置的节点
            Node curr = pre.next;
            //要找到i位置的下一个节点
            Node nextNode = curr.next;
//          前一个节点，指向下一个节点
            pre.next=nextNode;
            //元素个数-1
            N--;
            return curr.item;
        }

        //查找元素t在链表中第一次出现的位置
        public int indexOf(T t){
            //从头结点开始，依次找出每一个节点， 取出item，和t比较，如果相同，就找到了
             Node n = head; //节点n为头结点

             for (int i=0;n.next!=null;i++){
                 n=n.next;
                 if (n.item.equals(t)){
                     return i;
                 }
             }

             return -1;

        }
    }

测试

package algorithm.linear;

public class LinkListTest {
    public static void main(String[] args) {
        //创建单项链表对象
        LinkList<String> SL = new LinkList<>();

        //测试插入
        SL.insert("姚明");
        SL.insert("科比");
        SL.insert("麦迪");
        SL.insert(1,"詹姆斯");

        for (String s:SL){
            System.out.println(s);
        }

        System.out.println("-----------");

        //测试获取
        String getResuit = SL.get(1);
        System.out.println("获取索引1处的结果为："+getResuit);
        //测试删除
        String removeResult = SL.remove(0);
        System.out.println("删除元素是"+removeResult);
        //测试清空
        SL.clear();
        System.out.println("清空后的线性表中的元素个数为："+SL.length());

    }
}

迭代器，这个是用来遍历集合的
我在ArrayList中也找到了实现和重写的源码