Java实现双链表

源码

package firstuse;

interface  ILink {
    /**
     * 链表增加节点操作
     * @param data 节点内容
     * @return
     */
    boolean add(Object data);

    /**
     * 判断指定内容节点在链表中是否存在
     * @param data 要判断的内容
     * @return 返回找到的节点索引
     */
    int contains(Object data);

    /**
     * 删除指定内容节点
     * @param data
     * @return
     */
    boolean remove(Object data);

    /**
     * 根据指定下标修改节点内容
     * @param index 索引下标
     * @param newData 替换后的内容
     * @return 替换之前的节点内容
     */
    Object set(int index,Object newData);

    /**
     * 根据指定下标返回节点内容
     * @param index
     * @return
     */
    Object get(int index);

    /**
     * 链表清空
     */
    void clear();

    /**
     * 将链表转为数组
     * @return 返回所有节点内容
     */
    Object[] toArray();

    /**
     * 链表长度
     * @return
     */
    int size();

    /**
     * 遍历链表
     */
    void printLink();
}
class LinkImpl implements ILink{
    private Node first;
    private Node last;
    private int size = 0;
    private class Node{
        private Node prev;
        private Object data;
        private Node next;
        public  Node(Node prev,Object data,Node next){
           this.prev = prev;
           this.data = data;
           this.next = next;
        }
    }
    public boolean add(Object data) {
        Node newNode = new Node(this.last,data,null);
        if(this.first == null){
            this.first = newNode;
        }
        else{
            this.last.next = newNode;
        }
        this.last = newNode;
        this.size++;
        return true;
    }

    @Override
    public int contains(Object data) {
        int index = 0;
        if(data == null){
            for(Node temp=first; temp!=null; temp=temp.next){
                if(temp.data == null){
                   return index;
                }
                index++;
            }
            return -1;
        }
        for(Node temp=first; temp!=null; temp=temp.next) {
             if(data.equals(temp.data)){
                return index;
             }
             index++;
        }
        return -1;
    }

    @Override
    public boolean remove(Object data) {
        if(data == null){
            for(Node temp=first; temp!=null; temp=temp.next){
                if(temp.data == null){
                    unLink(temp);
                    return true;
                }
            }
            return false;
        }
        for(Node temp=first; temp!=null; temp=temp.next){
            if(data.equals((temp.data)){
                unLink(temp);
                return true;
            }
        }
        return false;
    }

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

    @Override
    public Object get(int index) {
        if(isLinkIndex(index)){
            return node(index).data;
        }
        return null;
    }

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

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

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

    @Override
    public void printLink() {
        Object[] data = this.toArray();  //字符串变成字符串数组
        for(Object temp:data){
            System.out.println(temp);
        }
    }
    /**
     * 根据指定索引取得具体节点
     * @param index
     * @return
     */
    private Node node(int index) {
        //从前往后找快
        if(index<(size>>1)){
            Node temp = first;
            //走index步
            for(int i=0; i<index; i++){
               temp = temp.next;
            }
            return temp;
        }
        //否则从后往前找快
        Node temp = last;
        //走index步
        for(int i=size-1; i>index; i--){
            temp = temp.prev;
        }
        return temp;
    }
    /**
     * 判断指定索引是否合法
     */
    private boolean isLinkIndex(int index){
        return (index>=0) && (index<size);
    }
    //删除指定的结点
    private Object unLink(Node node){
        Object elementData = node.data;
        Node prev = node.prev;
        Node next = node.next;
        if(prev != null){
            //该节点不是头节点
            prev.next = next;
            node.prev = null;
        }
        else{//是头节点
            this.first = next;
        }
        if(next !=  null){
            //不是尾节点
            next.prev = prev;
            node.next = null;
        }
        else{
            //是尾节点
            this.last = prev;
        }
        this.size--;
        return elementData;
    }
}

public class Test1 {
    public static void main(String[] args) {
        ILink link = new LinkImpl();
        link.add("火车头");
        link.add("车厢1");
        link.add("车厢2");
        link.add("火车尾");
        link.printLink();
        Object a = link.get(2);
        System.out.println(a);
        System.out.println(link.contains("火车尾"));
        System.out.println(link.contains("哈哈哈"));
        System.out.println(link.contains(null));
        System.out.println(link.set(3,"嘻嘻嘻"));
        link.printLink();
        System.out.println(link.remove("嘻嘻嘻"));
        link.printLink();
        System.out.println(link.remove("哈哈哈"));
    }
}