java之数据结构(单链表简单实现LinkedList)

List接口
List.java

public interface List {
	// 返回线性表的大小，即数据元素的个数。
	public int size();

	// 返回线性表中序号为 i 的数据元素
	public Object get(int i);

	// 如果线性表为空返回 true，否则返回 false。
	public boolean isEmpty();

	// 判断线性表是否包含数据元素 e
	public boolean contains(Object e) throws ArrayIndexOfBoundsException;

	// 返回数据元素 e 在线性表中的序号
	public int indexOf(Object e);

	// 将数据元素 e 插入到线性表中 i 号位置
	public boolean add(int i, Object e);

	// 将数据元素 e 插入到线性表末尾
	public boolean 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);


}

结点类
Node.java

public class Node {
    Object data;
    Node next;
    Node prev;

    public Node() {
    }

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

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

    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;
    }

    public Node getPrev() {
        return prev;
    }

    public void setPrev(Node prev) {
        this.prev = prev;
    }
}

实现类SingleLinkedList
SingleLinkedList.java

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) {
        //定义一个结点指向Head
        Node p = Head;

        //从头反复获取下一个值,直到获取到第i个为止
        for(int j = 0;j<=i;j++){

            //反复获取
            p = p.next;
        }

        //返回数据
        return p.data;
    }

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

    @Override
    public boolean contains(Object e){
        if (size < 0) {
            throw new ArrayIndexOfBoundsException("此数据为空");
        } else {
            Node p = Head;
            for (int i = 0; i < size; i++) {
                p = p.next;
                if (p.data.equals(e)) {
                    return true;
                }
            }
            return false;
        }
    }

    // 返回数据元素 e 在线性表中的序号
    @Override
    public int indexOf(Object e) {
        /** //数据重复
        int i;
        if (size < 0) {
            throw new ArrayIndexOfBoundsException("此数据为空");
        } else {
            Node p = Head;
            for (i = 0; i < size; i++) {
                p = p.next;
                if (p.data.equals(e)) {
                    return i;
                }
            }

        }
        return -1;
         */
        return Index(e);
    }

    @Override
    public boolean add(int i, Object e) {
        //找到第一个节点,从head开始
        Node p = Head;

        for (int j = 0; j < i; j ++) {
            p = p.next;
            //System.out.println(p.next);
        }
        //        /建一个节点/新
        Node newNode = new Node();

        newNode.data = e;
        //指明新结点的后继结点
        newNode.next = p.next;//把 新结点的next值赋为null
        //System.out.println(p.next);

        //指明新结点的直接前驱节点
        p.next = newNode;

        //加一个大小就增加1
        size ++;

        return true;
    }

    @Override
    public boolean add(Object e) {
        this.add(size,e);
        return true;
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        if(Index(obj)>=0) {
            add(Index(obj), e);
            return true;
        }
        return false;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        /**  //方法重复
        int i;
        if (!this.contains(obj)) {
            throw new ArrayIndexOfBoundsException("此数据不存在");
        } else {
            Node p = Head;
            for ( i = 0; i < size; i++) {
                p = p.next;
                if (p.data.equals(obj)) {
                    add(i+1,e);
                    return true;
                }
            }
        }
        return false;
         */
        if(Index(obj)>=0) {
            add(Index(obj) + 1, e);
            return true;
        }
        return false;
    }

    @Override
    public Object remove(int i) {

        Node p1 = Head;
        Node p = Head;
        Node p2 = Head;

        for (int j = 0; j < i; j ++) {
            p1 = p1.next;
        }

        for (int j = 0; j < i+1; j ++) {
            p = p.next;
        }

        for (int j = 0; j < i+2; j ++) {
            p2 = p2.next;
        }
        p.next = null;
        p1.next = p2;
        size --;
        return p.data;

    }

    @Override
    public boolean remove(Object e) {
        int i = Index(e);
        remove(i);
        size --;
        return true;
    }

    // 替换线性表中序号为 i 的数据元素为 e，返回原数据元素
    @Override
    public Object replace(int i, Object e) {
        Node p = Head;

        for (int j = 0; j < i; j ++) {
            p = p.next;
            //System.out.println(p.next);
        }
        Object c = p.data;
        p.data = e;
        return c;
    }

     public int Index(Object obj){
        int i = -1;
        if (!contains(obj)) {
            throw new ArrayIndexOfBoundsException("此数据不存在");
        } else {
            Node p = Head;
            for ( i = 0; i < size; i++) {
                p = p.next;
                if (p.data.equals(obj)) {
                    //add(i,e);
                    return i;
                }
            }
        }
        return i;
    }
}

自定义异常类ArrayIndexOfBoundsException
ArrayIndexOfBoundsException.java

public class ArrayIndexOfBoundsException extends RuntimeException{
    public ArrayIndexOfBoundsException() {
    }

    public ArrayIndexOfBoundsException(String message) {
        super(message);
    }
}

测试类自己写