JAVA---手写单链表

JAVA—手写单链表

LIst接口

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);
    public Iterator iterator();
}

Node结点

//单链表的结点
public class Node {
    public Object data; // 存储元素
    public Node next; //指向下一个结点

    public Node() {
    }

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

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

    public Object getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }

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

SingleLinkedList类

public class SingleLinkedList implements List {
    private Node head = new Node();  //头结点，不存储任何元素，初始创建，用来指向第一个真正的数据结点
    private int size;      //结点的数量，元素的个数
    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {
        //按照索引查询数据，从0开始
        //指向头结点
        Node p = head;
        //从头开始，以此指向下一个结点
        for (int index = 0; index <= i;index++){
            p = p.next;
        }
        return p;//返回当前结点
    }

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

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

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

    @Override
    public void add(int i, Object e) {
        //先让前一个结点指向头结点
        Node previousNode = head;
        if (i > 0){  //如果索引是0，前一个系结点就是头结点
            //找到i-1的结点
            previousNode = (Node) get(i-1);
        }
        //添加的结点(值)
        Node newNode = new Node(e);
        //添加的结点指向第i个结点
        newNode.next = previousNode.next;
        //上一个结点指向添加的结点
        previousNode.next = newNode;
        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) {
        //先让前一个结点指向头结点
        Node previousNode = head;
        if (i > 0){  //如果索引是0，前一个系结点就是头结点
            //找到i-1的结点
            previousNode = (Node) get(i-1);
        }
        //获取当前结点
        Node currentNode = previousNode.next;
        //获前个结点指向下一个结点
        previousNode.next = currentNode.next;
        //当前结点不在指向其他结点了
        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 sb = new StringBuilder("[");
        //指向头结点
        Node p = head;
        //从头开始，以此指向下一个结点
        for (int index = 0; index < size;index++){
            p = p.next;
            //如果是最后一个,不添加逗号
            if (index == size - 1){
                sb.append(p.data);
            }else {
                //添加到缓冲区
                sb.append(p.data + ",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}