java实现双链表

双链表实现（java）
定义接口
package Node;

/**

• 线性表规范
• @author: yuisama
• @date: 2019-02-28 19:46
• @description:
  */

interface Sequence {
/**
* 向线性表中添加元素
* @param data 要存储的元素
*/
void add(Object data);

/**
 * 线性表中删除元素
 * @param index 要删除的元素下标
 * @return 是否删除成功
 */
boolean remove(int index);

/**
 * 在线性表中查找指定索引的元素
 * @param index 要查找的索引
 * @return
 */
Object get(int index);

/**
 * 判断线性表中是否有指定元素
 * @param data 要查找的元素内容
 * @return
 */
boolean contains(Object data);

/**
 * 修改线性表中指定索引的内容
 * @param index 要修改的元素下标
 * @param newData 修改后的内容
 * @return
 */
Object set(int index, Object newData);

/**
 * 返回当前线性表元素个数
 * @return
 */
int size();

/**
 * 直接清空线性表内容
 */
void clear();

/**
 * 将线性表转为数组
 * @return
 */
Object[] toArray();

}
实现类
package Node;

public class DoubleLinkedList implements Sequence {
//头结点
private Node head;
//尾节点
private Node Last;
//链表长度
private int size;
private class Node{
private Node prev;
private Node next;
private Object data;

    public Node(Node prev, Object data, Node next) {
        this.prev = prev;
        this.next = next;
        this.data = data;
    }
}
@Override
public void add(Object data) {
    //定义前驱节点
    Node temp = this.Last;
    //定义新结点
    Node newNode = new Node(temp,data,null);
    this.Last = newNode;
    if (this.head == null){
        this.head = newNode;
    }else {
        temp.next = newNode;
    }
    size++;
}

@Override
public boolean remove(int index) {
    isLinkIndex(index);
    Node cur = node(index);
    Node prev = cur.prev;
    Node next = cur.next;
    //删除的为头结点
    if (prev == null){
        head = cur.next;
    }else{
        prev.next = cur.next;
        cur.prev = null;
    }
    //删除的是尾节点
    if(cur.next == null){
        Last = cur.prev;
    }else {
        next.prev = cur.prev;
        cur.prev = null;
    }
    size--;
    return false;
}

@Override
public Object get(int index) {
    //判断下表合法
    isLinkIndex(index);
    return node(index).data;
}

/**
 * 根据下标取得数据
 * @param index
 * @return
 */
private  Node node(int index) {
    //判断节点位置是否处于链表中间位置前后
    if(index < size>>1){
        //从头开始找
        Node temp = head ;
        for(int i = 0 ;i <index ; i++ ){
            temp = temp.next;
        }
        return temp;
    }
    //从尾部开始找
    Node temp = Last;
    for (int i = size -1 ; i > index ; i--){
        temp = temp.prev;
    }
    return temp;
}

@Override
public boolean contains(Object data) {
    Object[] arr = toArray();
    for (int i = 0; i < size ;i++){
        if (arr[i] == data){
            return true;
        }
    }
    return false;
}

@Override
public Object set(int index, Object newData) {
    isLinkIndex(index);
    Node node = node(index);
    Object oldnode = node.data ;
    node.data = newData;
    return oldnode;
}

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

@Override
public void clear() {
    for (Node temp = head;temp!=null;){
        temp.data = null;
        Node node = temp.next;
        temp.prev = temp.next = null ;
        node = temp;
        size--;
    }

}

@Override
public Object[] toArray() {
    Object[] arr = new Object[size];
    int i = 0;
    for (Node temp = head ;temp != null;temp = temp.next){
        arr[i++] = temp.data ;
    }
    return arr;
}
private void isLinkIndex(int index){
    if (index < 0 ||index >= size){
        throw new IndexOutOfBoundsException("下标不合法");
    }
}

}