JAVA-手动实现链表

节点

package com.ghgcn.nio.linklist;

/**
 * 节点
 * 
 * @author Administrator
 *
 */
public class Node {

    /**
     * 数据
     */
    public Object data;
    /**
     * 前一个
     */
    public Node prev;
    /**
     * 下一个
     */
    public Node next;

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

    // 显示此节点
        public void display() {
            System.out.print(data + " ");
        }

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


}

链表

package com.ghgcn.nio.linklist;

import java.util.NoSuchElementException;

/**
 * 双向链表 J
 * 
 * @see java.util.LinkedList
 * @author Administrator
 *
 */
public class DoubleLinkList {

    int size = 0;
    /**
     * 第一个
     */
    Node first;

    /**
     * 最后一个
     */
    Node last;

    public DoubleLinkList() {
        this.first = null;
        this.last = null;
    }

    /**
     * 默认添加元素到最后
     * 
     * @param node
     */
    public void add(Node node) {
        addLast(node);
    }

    public void addIndex(int index, Node node) {

        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("下标不正确");
        }
        if (index == size) {
            addLast(node);
        } else {
            addBefore(index, node);
        }
    }

    private void addBefore(int index, Node node) {

        Node x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        /**
         * 要插入的位置的前一个元素
         */
        Node pred = x.prev;
        /*
         * 要插入的元素
         */
        Node newNode = new Node(node.data, pred, x);
        /**
         * 指定前置
         */
        x.prev = newNode;
        /**
         * 判断不是空,是不是只有一个元素
         */
        if (pred == null) {
            first = newNode;
        } else {
            // 指定后置元素为要添加的元素
            pred.next = newNode;
        }
        size++;
    }

    public void removeIndex(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("下标不正确");
        }

        Node current = first;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        /**
         * 获取前一个元素
         */
        Node prev = current.prev;
        /**
         * 获取后五个元素
         */
        Node next = current.next;

        /**
         *  判断前面的元素是不是为空
         *  是没有第一个了,没有就把first赋值 为next
         */
        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            current.prev = null;
        }
        /**
         * 判断是不是最后
         */
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            current.next = null;
        }

        size--;

    }

    /**
     * 添加到第一个
     * 
     * @param node
     */
    public void addFirst(Node node) {
        linkFirst(node);
    }

    private void linkFirst(Node node) {

        Node f = first;
        Node newNode = new Node(node.data, null, f);
        first = newNode;
        /**
         * 如果只有一个元素
         */
        if (f == null) {
            last = newNode;
        } else {
            f.prev = newNode;

        }
        size++;
    }

    /**
     * 添加到最后
     * 
     * @param node
     */
    public void addLast(Node node) {

        Node l = last;
        Node newNode = new Node(node.data, l, null);
        last = newNode;
        /**
         * 如果只有一个元素
         */
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }

    public Node getFirst() {
        return first;
    }

    public Node getLast() {
        return last;
    }

    /**
     * 移除第一个
     * 
     * @return
     */
    public Node removeFirst() {
        Node f = first;
        if (f == null) {
            throw new NoSuchElementException();
        }
        return unlinkFirst(f);
    }

    /**
     * 删除第一个
     * 
     * @param f
     * @return
     */
    private Node unlinkFirst(Node f) {
        Node next = f.next;
        first = next;
        if (next == null) {
            last = null;
        } else {
            next.prev = null;
        }
        size--;
        return next;
    }

    /**
     * 移除最后一个
     * 
     * @return
     */
    public Node removeLast() {
        Node l = last;
        if (l == null) {
            throw new NoSuchElementException();
        }
        return unlinklast(l);
    }
    /**
     * 删除
     * @param l
     * @return
     */
    private Node unlinklast(Node l) {

        Node pre = l.prev;
        last = pre;
        if (pre == null) {
            first = null;
        } else {
            pre.next = null;
        }
        size--;
        return l;
    }

    /**
     * 获取指定位置
     * @param index
     * @return
     */
    public Node getIndex(int index){

        if(index<0 || index>size){
            throw new IndexOutOfBoundsException("下标越界");
        }
        Node currnt = first;
        for( int i =0; i<index;i++){
            currnt=currnt.next;
        }
        return currnt;
    }

    public void display() {

        for (Node x = first; x != null; x = x.next) {
            x.display();
        }

    }

    public int size() {
        return size;
    }


}

测试

package com.ghgcn.nio.linklist;

public class Test1 {

    public static void main(String[] args) {

        DoubleLinkList doubleLinkList = new DoubleLinkList();

        doubleLinkList.addFirst(new Node(1));
        doubleLinkList.addLast(new Node(5));
        doubleLinkList.addFirst(new Node(3));
        doubleLinkList.add(new Node(-1));
        System.out.println(doubleLinkList.size);
        doubleLinkList.display();
        System.out.println("\n添加到指定位置");
        doubleLinkList.addIndex(3,new Node(0));
        System.out.println();
        doubleLinkList.display();
        doubleLinkList.addIndex(1,new Node(9));
        System.out.println();
        doubleLinkList.display();
        doubleLinkList.addIndex(6,new Node(8));
        System.out.println();
        doubleLinkList.display();
        doubleLinkList.removeIndex(3);
        System.out.println();
        doubleLinkList.display();
        System.out.println("\n######  获取指定位置   ######");
        System.out.println(doubleLinkList.getIndex(0).data);

    }

}

结果

4
3 1 5 -1 
添加到指定位置

3 1 5 0 -1 
3 9 1 5 0 -1 
3 9 1 5 0 -1 8 
3 9 1 0 -1 8 
######  获取指定位置   ######
3