数据结构之--双链表MyLinkedList

　　双链表的手动实现中考虑三个类的实现：

1、MyLinkedList类本身的实现，包含到两端的链、表的大小以及一些方法。

2、Node节点，它可能是一个私有的内部嵌套类，这个类，嵌套在MyLinkedList的内部，数据域：data，前驱指针prev和后继指针next，以及合适的构造方法

3、LinkedListIterator类，该类抽象了位置的概念，是一个实现了Iterator接口的私有类，它提供了next、hashNext和remove等方法。于我而言这个迭代器的实现感觉比较的有收获。主要注意要实现的是：我们在使用迭代器件，确保链表集合中的元素不会被用户越过迭代器而修改。都有过这样的经历：在java中执行迭代操作的过程中，比如：

LinkedList <Integet> kist = new LinkedList<Integer>();
……
Iterator<Integer> it = list.iterator();
while(it.hasNext())
{
    syso(it.next);
    list.remove(1);// 这里就会报错，这里面有一套保护机制，确保在使用迭代期间不允许使用集合和修改内部元素
   it.remove();       // 这样同通过迭代器的修改是允许的
}

主要实现上面的保护机制。其实就是一个维护一个互斥变量的感觉。

具体的实现代码如下：

import java.util.Iterator;

import org.omg.CORBA.Any;

/**
 * 自己手动实现一个 LinkedList
 * 基于双向链表，其中，私有嵌套定义双向链表的节点
 * 注意了我哥双向链表，n个元素记做1~n,标准库中记为0~n-1
 * @author Administrator
 *
 */
public class MyLinkedList <AnyType> implements Iterable<AnyType>{
    private int theSize;    //双向链表中的元素个数
    private int modCount;    //这个标记为了配合Iterator实现修改的保护，这一点后面专做论述,凡是做了增删修改，这个标记均变化
    private Node<AnyType> beginMarker;    // 双向链表的开始标记
    private Node<AnyType> endMarker;    //双向链表的尾部标记
    
    public MyLinkedList()
    {
        // 构造函数 先初始化双向聊表 调动 clear()函数
        clear();
    }
    public void clear()
    {// 确保双向链表处于空的状态 ----> 我们使用一个辅助的头结点
        // 头标记和尾标记 指向同一个 辅助头结点,和一个辅助的尾节点
        beginMarker = new Node<AnyType>(null, null, null);
        endMarker   = new Node<AnyType>(null, beginMarker, null);
        beginMarker.next = endMarker;
        
        theSize = 0;
        modCount ++;    //zhege
    }
    
    // 获取元素的个数
    public int size()
    {
        return theSize;
    }
    
    // 判断是否为空
    public boolean isEmpty()
    {
        return theSize == 0;
    }
    
    
    /*
     * 增删查改的操作
     */
    // 默认把元素插入到尾部,其中调用插入到指定位置的函数
    public boolean add(AnyType x)
    {
        add(size()+1, x);
        return true;
    }
    // 把元素插入到指定位置，其中调用插入到指定元素之前 函数
    public void add(int idx, AnyType x)
    {
        addBefore(getNode(idx), x);
    }
    // 重置某个节点的data值，并返回以前的 data值
    public AnyType set(int idx, AnyType newVal)
    {
        if(idx <1 || idx >size())
            throw new RuntimeException(new Exception("下表越界"));
        Node<AnyType> p = getNode(idx);
        AnyType oldVal = p.data;
        p.data = newVal;
        return oldVal;
    }
    // 删除第idx个节点,调用remove(Node)函数，返回删除节点的data值
    public AnyType remove(int idx)
    {
        if(idx <1 || idx >size())
            throw new RuntimeException(new Exception("下表越界"));
        return remove(getNode(idx));
    }
    
    
    
    /*
     * 下面这些函数都是一些private的都是位别的一些函数服务的
     */
    // 在p前面插入 x 元素
    private void addBefore(Node<AnyType>p, AnyType x)
    {
        Node<AnyType> newNode = new Node<AnyType>(x, p.prev, p);
        newNode.prev.next = newNode;
        p.prev = newNode;
        theSize ++;        //添加进来一个新元素之后，别忘了元素个数++
        modCount ++;    //无论增删 该标志 均++
    }
    // 获取 idx处的 节点引用
    private Node<AnyType> getNode(int idx)
    {
        if(idx < 1 || idx > size()+1)// 考虑在尾部插入的情况，如果取这个尾节点，其data = null
            throw new RuntimeException(new Exception("索引越界"));
        Node<AnyType> p = null;
        if( idx <= size()/2)    // 在前半边中找
        {
            p = beginMarker.next;
            for( int i = 1; i < idx; i++)
                p = p.next;
        }else{    //在后半边中找
            p = endMarker;
            for(int i = size(); i >= idx; i--)
                p = p.prev;
        }
        
        return p;
    }
    // 返回 删除某个节点，并返回这个节点的data值
    private AnyType remove(Node<AnyType> p)
    {
        p.prev.next = p.next;
        p.next.prev = p.prev;
        theSize --;
        modCount --;
        return p.data;
    }
    
    
    /*
     * 实现迭代器
     */
    public Iterator<AnyType> iterator()
    {
        return new LinkedListIterator();
    }
    //实现迭代器
    private class LinkedListIterator implements Iterator<AnyType>
    {
        private Node<AnyType> current = beginMarker.next;    //记住当前的位置，这和书序表中类似
        private int expectedModCount = modCount;
        private boolean okToRemove = false;
        
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return current!=endMarker;
        }

        @Override
        public AnyType next() {
            // 注意了 下面的 保护迭代期间 不允许 越过迭代器修改集合元素的 机制 是精髓
            if(modCount != expectedModCount)
                throw new RuntimeException(new Exception("您刚刚越过迭代器修改了集合元素"));
            if(!hasNext())
                throw new RuntimeException(new Exception("已经没有元素了"));
                
            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {
            // TODO Auto-generated method stub
            if(modCount != expectedModCount)
                throw new RuntimeException(new Exception("您刚刚越过迭代器修改了集合元素"));
            if(!okToRemove)
                throw new RuntimeException(new Exception("先next再删除"));
            
            MyLinkedList.this.remove(current.prev);
            okToRemove = false;    // 与next()中的 okToRemove = false； 遥相呼应，以确保必须在next()之后才能remove
            expectedModCount ++;    
        }
        
    }
    
    /*
     * 私有嵌套类的形式，定义内部节点，节点里面没有访问双向链表中的内容，所以使用私有嵌套类可也
     * 如果访问了外面类的属性或者方法就只能使用内部类，去除static关键字,内部类的使用主要是为了可以简写，见单链表中的介绍
     */
    private static class Node<AnyType>{
        // 构造函数
        public Node(AnyType d, Node<AnyType>p, Node<AnyType>n) {
            data = d; prev = p; next = n;
        }
        
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;
    }
    
    public static void main(String[] args) {
        MyLinkedList<Integer> list= new MyLinkedList<Integer>();
        
        System.out.println("size : "+list.size());
        System.out.println("empty : "+list.isEmpty());
        list.add(1);
        list.add(2);
        list.add(4);
        list.add(3, 3);
        System.out.println("size : "+list.size());
        System.out.println("empty : "+list.isEmpty());
        
        list.set(4, 5);
        
        System.out.println("dlete 4th elements :"+list.remove(4));
        System.out.println("size : "+list.size());
    }
}