JAVA学习-数据结构-LinkedList

说明：https://mp.csdn.net/mdeditor/94589662#
ArrayList 和 LinkedList都是List的实现类。ArrayList是通过维护一个数组实现，而LinkedList是通过维护链表实现的。
代码如下：
（两个结构的方法差不多，不过有些方法的复杂度不同，取决于他们的内部数据结构）
至于迭代器的实现，我是自己用内部类的方式。当然也可以用别的方式。

package code.hc.util;

public class HLinkedList<E> implements HList<E>, HDeque<E> {

    private ListNode headNode;
    private ListNode tailNode;
    private int size;

    public HLinkedList(){
        headNode = null;
        tailNode = null;
        size = 0;
    }

    @Override
    public HListIterator<E> listIterator() {
        return new HLinkedListIterator();
    }

    @Override
    public void add(E e) {
        addLast(e);
    }

    @Override
    public boolean isEmpty() {
        return headNode == null;
    }

    @Override
    public HIterator<E> iterator() {
        return new HCollectionIterator();
    }

    @Override
    public boolean contain(E e) {
        ListNode point = headNode;
        while(point != null){
            if(point.obj.equals(e))return true;
            point = point.next;
        }
        return false;
    }

    @Override
    public void remove(E e) {
        if(headNode.obj.equals(e)){
            removeFirst();
            return;
        }
        ListNode curNode = headNode;
        while(curNode.next != null){
            if(e.equals(curNode.obj)){
                curNode.next = curNode.next.next;
                curNode.next.previous = curNode;
                size = size - 1;
            }
        }
    }

    @Override
    public boolean remove(int index) {
        if(index < 0 || index >= size)return false;
        if(index == 0){
           ListNode tempNode = headNode.next;
           headNode = null;
           headNode = tempNode;
           headNode.previous = null;
        }else {
            ListNode father = headNode;
            while(index > 1){
                father = father.next;
                index = index - 1;
            }
            father.next = father.next.next;
            father.next.next.previous = father;
        }
        size = size - 1;
        return true;
    }

    @Override
    public void clear() {
        while(headNode != null){
            ListNode nextNode = headNode.next;
            headNode = null;
            headNode = nextNode.next;
            headNode.previous = null;
        }tailNode = null;
        size = 0;
    }

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

    @Override
    public void addFirst(E e) {
        if(headNode == null){
            headNode = new ListNode(e);
            tailNode = headNode;
        }else {
            ListNode newNode = new ListNode(e);
            newNode.next = headNode;
            headNode.previous = newNode;
            headNode = headNode.previous;
        }
        size = size + 1;
    }

    @Override
    public void addLast(E e) {
        if(tailNode == null){
            tailNode = new ListNode(e);
            headNode = tailNode;
        }else {
            ListNode newNode = new ListNode(e);
            newNode.previous = tailNode;
            tailNode.next = newNode;
            tailNode = tailNode.next;
        }
        size = size + 1;
    }

    @Override
    public E getFirst() {
        if(headNode == null)return null;
        return headNode.obj;
    }

    @Override
    public E getLast() {
        if(tailNode == null) return null;
        return tailNode.obj;
    }

    @Override
    public void removeFirst() {
        if(headNode != null){
            ListNode nextNode = headNode.next;
            headNode = null;
            headNode = nextNode;
            headNode.previous = null;
            size = size - 1;
        }
    }

    @Override
    public void removeLast() {
        if(tailNode != null){
            ListNode preNode = tailNode.previous;
            tailNode = null;
            tailNode = preNode;
            tailNode.next = null;
            size = size - 1;
        }
    }

    private class ListNode {
        private E obj;
        private ListNode next;
        private ListNode previous;

        ListNode(E o){
            obj = o;
            next = null;
            previous = null;
        }
    }

    private class HLinkedListIterator implements HListIterator<E>{

        private ListNode curNode;
        private HLinkedListIterator(){
            curNode = headNode;
        }
        @Override
        public boolean hasPrevious() {
            return curNode != null;
        }

        @Override
        public E previous() {
            E node = curNode.obj;
            curNode = curNode.previous;
            return node;
        }

        @Override
        public boolean hasNext() {
            return curNode != null;
        }

        @Override
        public E next() {
            E node = curNode.obj;
            curNode = curNode.next;
            return node;
        }
    }

    private class HCollectionIterator implements HIterator<E> {
        private ListNode curNode;

        private HCollectionIterator(){
            curNode = headNode;
        }

        @Override
        public boolean hasNext() {
            return curNode != null;
        }

        @Override
        public E next() {
            E node = curNode.obj;
            curNode = curNode.next;
            return node;
        }
    }
}