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 SequenceLinkImpl implements Sequence {
    // 虚拟头节点，不存储元素，专门作为头节点使用
    private Node dummyHead;
    private int size;

    public SequenceLinkImpl() {
        this.dummyHead = new Node(null,null);
    }

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

    @Override
    public void add(Object data) {

        addLast(data);
    }

    @Override
    public boolean remove(int index) {
        rangeCheck(index);
        Node prev = dummyHead;
        for (int i = 0;i < index;i++) {
            prev = prev.next;
        }
        // 取得当前节点
        Node cur = node(index);
        prev.next = cur.next;
        // 清空当前节点
        cur.next = cur = null;
        size --;
        return true;
    }

    @Override
    public Object get(int index) {
        rangeCheck(index);
        // 取得相应index的Node节点
        Node node = node(index);
        return node.data;
    }

    @Override
    public boolean contains(Object data) {
        Object[] datas = toArray();
        if (data == null) {
            for (int i = 0;i < datas.length;i++) {
                if (datas[i] == null) {
                    return true;
                }
            }
        }else {
            for (int i = 0;i < datas.length;i++) {
                if (data.equals(datas[i])) {
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public Object set(int index, Object newData) {
        rangeCheck(index);
        // 取得相应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 node = dummyHead.next;node != null;) {
            node.data = null;
            Node temp = node.next;
            node.next = null;
            node = temp;
            size--;
        }
    }

    @Override
    public Object[] toArray() {
        // 遍历节点将数据存放到对象数组中
        Object[] datas = new Object[size];
        int i = 0;
        for (Node temp = dummyHead.next;temp!=null;temp = temp.next) {
            datas[i++] = temp.data;
        }
        return datas;
    }
    // 在任意位置插入元素
    public void add(int index,Object data) {
        rangeCheck(index);
        Node prev = dummyHead;
        for (int i = 0;i < index;i++) {
            prev = prev.next;
        }
        Node newNode = new Node(data);
        newNode.next = prev.next;
        prev.next = newNode;
        size++;
    }
    private void addFirst(Object data) {
        add(0,data);
    }
    private void addLast(Object data) {
        add(size,data);
    }
    // 判断index是否合法
    private void rangeCheck(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Illegal Index!");
        }
    }
    // 找到index的当前节点
    private Node node(int index) {
        Node cur = dummyHead.next;
        for (int i = 0;i < index;i++) {
            cur = cur.next;
        }
        return cur;
    }
}