手写单链表

首先创建Node类

包括数据和指针

package list2;

/**
 * 单链表的一个节点
 */
public class Node {
     Object data;
    Node  next;

    public Node() {
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Node(Object data) {
        this.data = data;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Object getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

创建List接口（得到相关方法）

package list2;

import list.Iterator;

public interface List {
    // 返回线性表的大小，即数据元素的个数。
    public int size();
    // 返回线性表中序号为 i 的数据元素
    public Object get(int i);
    // 如果线性表为空返回 true，否则返回 false。
    public boolean isEmpty();
    // 判断线性表是否包含数据元素 e
    public boolean contains(Object e);
    // 返回数据元素 e 在线性表中的序号
    public int indexOf(Object e);
    // 将数据元素 e 插入到线性表中 i 号位置
    public void add(int i, Object e);
    // 将数据元素 e 插入到线性表末尾
    public void add(Object e);
    // 将数据元素 e 插入到元素 obj 之前
    public boolean addBefore(Object obj, Object e);
    // 将数据元素 e 插入到元素 obj 之后
    public boolean addAfter(Object obj, Object e);
    // 删除线性表中序号为 i 的元素,并返回之
    public Object remove(int i);
    // 删除线性表中第一个与 e 相同的元素
    public boolean remove(Object e);
    // 替换线性表中序号为 i 的数据元素为 e，返回原数据元素
    public Object replace(int i, Object e);
//迭代List
    public Iterator iterator();

}

方法

package list2;

import list.Iterator;

import java.net.InetAddress;

public class SingleLinkedList implements List {
    private Node head = new Node();//存在头节点
    private int size;//节点数量
    public SingleLinkedList() {
        super();
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Node get(int i) {
        //健壮性判断
        if (i < 0 || i >= size) {
            throw new IndexOutOfBoundsException("索引越界："+i);
        }
        //定义一个指针p，指向头节点
        Node p = head;

        //循环i次找到第i个节点
        for (int j = 0; j <= i; j++) {
            p = p.next;
        }
        //返回第i个节点
        return p;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean contains(Object e) {
        return indexOf(e)>=0;//索引大于等于零
    }

    @Override
    public int indexOf(Object e) {
        return 0;
    }

    @Override
    public void add(int i, Object e) {
        //先获取第i-1个元素（如果i=0就是获取头节点）
        Node p=head;
        if (i > 0) {
            p = get(i - 1);
        }
        //新建一个节点并加入数据
        Node q = new Node(e);
        //指定新节点的下一个节点
        q.next = p.next;
        //前一个节点的下一个节点是新加入的节点
        p.next=q;
        size++;
    }

    @Override
    public void add(Object e) {
        add(size, e);
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        return false;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        return false;
    }

    @Override
    public Object remove(int i) {
        //先获取第i-1个节点（如果i=0，就是获取头节点）
        Node p = head;
        if (i > 0) {
            p = get(i - 1);
        }
        //指向当前第i个节点
        Node currentNode = get(i);
        p.next = currentNode.next;
        //使得第i个节点没有指向
        currentNode.next = null;
        size--;
        return null;
    }

    @Override
    public boolean remove(Object e) {
        return false;
    }

    @Override
    public Object replace(int i, Object e) {
        return null;
    }

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

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("[");
//        for (int i = 0; i < size; i++) {
//            Node node = get(i);
//            builder.append(node.data + ",");
//
//        }
        Node p = head;
        for (int i = 0; i < size; i++) {
            p = p.next;//p指向第i个节点
            builder.append(p.data + ",");
        }
        if (size != 0) {
            builder.deleteCharAt(builder.length() - 1);
        }
        builder.append("]");
        return builder.toString();
    }
}

进行链表测试

package list2;

public class TestList {
    public static void main(String[] args) {
        java.util.ArrayList list2;
        //创建线性顺序表
        List list = new SingleLinkedList();
        //向末尾添加元素
        list.add("11111");
        list.add("aaaaa");
        list.add("bbbbb");
        list.add("33333");
        list.add("22222");
        list.add(3, "AAAAA");
        list.remove(2);
        //进行各种操作验证添加
        System.out.println(list.size());
        System.out.println(list.get(0));
        System.out.println(list.isEmpty());
        System.out.println(list.contains("44444"));
        System.out.println(list.indexOf("22222"));
        System.out.println(list.toString());
    }
}