实现一个简单的LinkedList——高淇JAVA300讲笔记之LinkedList

    老高的这部分代码其实写的比较粗糙，比如头结点和尾节点都考虑的不是很全面，不过敲一遍用来理解LinkedList的原理还是不错的。实现了add()、get()、size()、remove()等方法。

    LinkedList也是有序，可重复的。底层实现是链表，线程不安全，效率高。查询慢，修改、插入、删除快。

    在写的时候在纸上画几个节点会比较好理解一点。

    

    先是Node类，用来表示一个节点：

package cn.bjsxt.collection;

//用来表示一个节点
public class Node {
    Node previous;  //上一个节点
    Object obj;  //该节点的对象
    Node next;  //下一个节点
    
    //无参构造器
    public Node() {
    }
    
    //有参构造器
    public Node(Node previous, Object obj, Node next) {
        super();
        this.previous = previous;
        this.obj = obj;
        this.next = next;
    }

    /**
     * 以下是getter和setter方法
     * @return
     */
    public Node getPrevious() {
        return previous;
    }

    public void setPrevious(Node previous) {
        this.previous = previous;
    }

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

}

    然后是我们自己写的LinkedList类：

package cn.bjsxt.collection;

public class SxtLinkedList {
    private Node first;  //头节点
    private Node last;  //尾节点
    
    private int size;  //LinkedList的大小
    
    //增加一个节点    
    public void add(Object obj) {
        Node n = new Node();
        
        //如果没有第一个节点
        if(first == null) {
            n.setPrevious(null);
            n.setObj(obj);
            n.setNext(null);
            
            first = n;
            last = n;  //这个节点既是第一个也是最后一个
        } else {
            //直接往last节点后增加新的节点
            n.setPrevious(last);  //把最后一个节点设为新节点的上一个节点
            n.setObj(obj);
            n.setNext(null);
            
            last.setNext(n);  //新节点设为当前最后一个节点的下一个节点
            
            last = n;  //新节点成为最后一个节点
    
        }
        size++;
    }
    
  //在指定位置插入一个新对象
    public void add(int index, Object obj) {
        rangeCheck(index);  //检查数组下标是否越界
        Node temp = node(index);  //指定位置上的节点
        
        Node newNode = new Node();
        newNode.obj = obj;
        
        if(temp != null) {
            Node up = temp.previous;  //原节点的上一个节点
            up.next = newNode;  //新节点设为上一个节点的下一个节点
            newNode.previous = up;  //上一个节点设为新节点的上一个节点
            
            newNode.next = temp;  //原节点设为新节点的下一个节点
            temp.previous = newNode;  //新节点设为原节点的上一个节点
            
            size++;
        }
    }
    
    //返回链表的大小
    public int size() {
        return size;
    }
    
    //数组下标越界检查
    private void rangeCheck(int index) {
        if(index<0 || index>=size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    //返回指定位置的元素
    public Object get(int index) {
        rangeCheck(index);  //检查数组下标是否越界
        
        Node temp = node(index);
        if(temp != null) {
            return temp.obj;
        }
        return null;
    }
    
    //返回指定位置的节点Node对象
    public Node node(int index) {
        Node temp = null;
        if(first != null) {
            temp = first;
            for(int i=0;i<index;i++) {
                temp = temp.next;
            }
        }
        return temp;
    }
    
    
    //删除指定位置上的节点
    public void remove(int index) {
        Node temp = node(index);
        
        if(temp != null) {
            Node up = temp.previous;
            Node down = temp.next;
            up.next = down;
            down.previous = up;
            size--;
        }
        
        
    }
    
    public static void main(String[] args) {
        SxtLinkedList list = new SxtLinkedList();
        list.add("aaa");
        list.add("bbb");
        list.add(1,"BBBB");
        System.out.println(list.size());
        System.out.println(list.get(2));
//        list.remove(1);
        System.out.println(list.get(1));
    }
    
    
}