Java 基于线性表的双链表实现（ 面试 ，笔试重点）

实现链表，先定义一个线性表的接口，其中包括如下方法：

• 向线性表中添加元素
• 线性表中删除元素
• 在线性表中查找指定索引的元素
• 判断线性表中是否有指定元素
• 修改线性表中指定索引的内容
• 返回当前线性表元素个数
• 直接清空线性表内容
• 将线性表返回为数组

public interface Sequence {
    /**
     * 向线性表中添加元素
     * @param t 要存储的元素
     */
    <T> void add(T t);

    /**
     * 线性表中删除元素
     * @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
     */
   <T> Object set(int index,Object newData);

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

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

    public Object[] toArray();
}

双链表的实现：

public class DoubleLinkedListImpl implements Sequence {
    private Node head;
    private Node tail;
    private int size;

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

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

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

    /**
     * 尾插法
     *
     * @param data 要存储的元素
     */
    @Override
    public void add(Object data) {
        //产生新的节点，尾插到链表中
        Node newNode = new Node(tail, data, null);
        if (head == null) {
            head = newNode;
        } else {
            tail.next = newNode;
        }
        tail = newNode;
        size++;
    }

    @Override
    public boolean remove(int index) {
        rangeCheck(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 (next == null){
            tail = cur.prev;
        }else{
            next.prev = cur.prev;
            cur.prev = null;
        }
        size--;
        return false;
    }

    @Override
    public Object get(int index) {
        rangeCheck(index);
        //取得指定位置的Node
        return node(index).data;
    }

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

    @Override
    public Object set(int index, Object newData) {
        rangeCheck(index);
        //取得指定位置的Node
        Node node = node(index);
        Object oldData = node.data;
        node.data = newData;
        return oldData;
    }

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

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

    @Override
    public Object[] toArray() {
        Object[] data = new Object[size];
        int i = 0;
        for(Node temp = head;temp != null;temp = temp.next){
            data[i++] = temp.data;
        }
        return data;
    }

    private void rangeCheck(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Illegal inedx!");
        }
    }
    private Node node(int index) {
        //此时要查找的节点在中间位置的左边
        if (index < (size >> 1)) {
            Node temp = head;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            return temp;
        } else {
            Node temp = tail;
            for (int i = size - 1; i > index; i--) {
                temp = temp.prev;
            }
            return temp;
        }
    }

}