MyLinkedList代码

public class MyLinkedList implements IList{

private class Node{

     public T date;  //存放对象数据
     public Node next;  //指针所指下一单元

}
public class MyIterator<T> implements IMyIterator<T>{
    private int linkIndex=0;

    @Override
    public boolean hashNext() {
        //递归查找结束条件
        //从当前位置开始，顺着哈希的哈希地址向下找
        if(getSize()==0||linkIndex>=getSize()){
            return false;
        }
        return true;
    }

    @Override
    public T next() {
        if(!hashNext())
            throw new RuntimeException("没有返回元素！");
        T element = (T) get(linkIndex);
        linkIndex++;
        return element;
    }

}
//创建链表起始为空
private Node head=null;



@Override
public int getSize() {
    Node p=head;
    int size =0;
    while(p!=null){
        size++;
        p=p.next;
    }
    return size;
}

@Override
public boolean isEmpty() {
    return getSize()==0;
}

@Override
public void clear() {
    head=null;

}

@Override
public T get(int position) {
    //检查下标是否合法
    checkpostion(position,"获取元素下标错误："+position);
    Node p=head;
    for(int i=0;i<position;i++){
        p=p.next;
    }
    return p.date;
}

@Override
public T set(int position, T element) {
    //检查下标是否合法
    checkpostion(position,"重置元素下标错误："+position);
    Node p=head;
    for(int i=0;i<position;i++){
        p=p.next;
    }
    T old =p.date;
    p.date=element;
    return old;
}

@Override
public void add(T element) {
    //创建出新节点
    Node newNode=new Node();
    newNode.date=element;
    newNode.next=null;
    //如果链表为空，直接添加
    if(null==head){
        head=newNode;
        return;
    }
    //从头找到尾部节点
    Node  p = head;
    while(p.next!=null){
        p=p.next;
    }
    //再连接新节点
    p.next=newNode;
}


//检查下标合法性，不合法抛异常
private void checkpostion(int position,String errorMessage){
    int size=getSize();
    if(position<0||position>=size)
        throw new RuntimeException(errorMessage);
}

@Override
public T remove(int position) {
    //检查下标是否合法
    checkpostion(position,"删除元素下标错误："+position);
    int size=getSize();
    if(position<0||position>=size)
        throw new RuntimeException("删除元素下标错误："+position);
    //position=0,删除首节点
    if(position==0){
        Node old=head;
        head=head.next;
        return old.date;
    }

    Node p=head; //前节点
    Node q=head.next; // 后节点
    for(int i=1;i<position;i++){
        p=q;
        q=q.next;
    }
    p.next=q.next;
    T result =q.date;
    return result;
}

@Override
public int findIndexof(T element) {
    //从头到尾遍历整个线性表
    Node p=head;
    int size=0;
    while(p!=null){
        //判断对象是否等价
        if(element!=null&&element.equals(p.date)||element==p.date)
            return size;
        p=p.next;
        size++;
    }

    return -1;
}

@Override
public boolean isContained(T element) {

    return findIndexof(element)>=0;
}


@Override
public String toString(){
    String result="MyLinkedList: (";
    Node p=head;
    while(p!=null){
        result+=" "+p.date+" ";
        p=p.next;
    }
    result+=" )";
    return result;
}

//递归
@Override
public void reverse() {
     Node p =head;
     head=ReverseLink(p);
}

//递归方法
private Node ReverseLink(Node head){
    Node newhead;
    if((head==null)||(head.next==null))
        return head;
    newhead=ReverseLink(head.next);//递归部分
    head.next.next=head;//回溯部分
    head.next=null;
    return newhead;
}

//循环

// @Override
// public void reverse() {
// //创建新节点
// Node pre=null; //前节点
// Node p=head; // 头结点
// Node q=head.next;//后结点
//while(p!=null){
// q=q.next; //后结点向后移
// p.next=pre; //头结点next指向前一结点
// pre=p; //第一个脱落，前结点和头结点均向后移一格
// p=q;
// }
// head=pre; //重新定义链表的头结点
// }

//返回一个迭代器
public IMyIterator<T> getIterator(){
    return new MyIterator<>();
}

}