public class MyLinkedList<AnyType> implements Iterable<AnyType>{
private static class Node<AnyType>{
public AnyType data;
public Node<AnyType> prex;
public Node<AnyType> next;
public Node(AnyType d,Node<AnyType> p,Node<AnyType> n){
data=d;
prex=p;
next=n;
}
}
private int theSize;//元素个数
private int modCount=0;//操作次数
private Node<AnyType> beginMarker;//开始指针,指向第一个元素的前一个位置
private Node<AnyType> endMarker;//末尾指针,指向最后一个元素的后一个位置
public MyLinkedList(){
doClear();
}
public void clear(){
doClear();
}
public void doClear(){
beginMarker=new Node<AnyType>(null,null,null);
endMarker=new Node<AnyType>(null,beginMarker,null);
beginMarker.next=endMarker;
theSize=0;
modCount++;
}
public int size(){
return theSize;
}
public boolean isEmpty(){
return size()==0;
}
//在p之前添加一个元素,内部调用,为public函数服务
private void addBefore(Node<AnyType> p,AnyType x){
Node<AnyType> newNode=new Node<>(x,p.prex,p);
newNode.prex.next=newNode;
p.prex=newNode;
theSize++;
modCount++;
}
//移除一个元素
private AnyType remove(Node<AnyType> p){
p.next.prex=p.prex;
p.prex.next=p.next;
theSize--;
modCount++;
return p.data;
}
//查找指定位置的元素,之所以添加lower和upper是为了避免使用thesize,为了避免不小心修改thesize
private Node<AnyType> getNode(int idx,int lower,int upper){
Node<AnyType> p;
if(idx<lower||idx>upper){
throw new IndexOutOfBoundsException();
}
if(idx<size()/2){
p=beginMarker.next;
for(int i=0;i<idx;i++){
p=p.next;
}
}
else
{
p=endMarker;
for(int i=size();i>idx;i--){
p=p.prex;
}
}
return p;
}
//得到指定位置的元素
private Node<AnyType> getNode(int idx){
return getNode(idx,0,size()-1);
}
//在末尾添加一个元素
public boolean add(AnyType x){
add(size(),x);
return true;
}
//在指定位置添加一个元素
public void add(int idx,AnyType x){
addBefore(getNode(idx,0,size()),x);
}
public AnyType get(int idx){
return getNode(idx).data;
}
//修改指定位置的值
public AnyType set(int idx,AnyType newVal){
Node<AnyType> p=getNode(idx);
AnyType oldVal=p.data;
p.data=newVal;
return oldVal;
}
public AnyType remove(int idx){
return remove(getNode(idx));
}
//添加迭代器
@Override
public Iterator<AnyType> iterator() {
// TODO Auto-generated method stub
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() {
// TODO Auto-generated method stub
if(modCount!=expectedModCount)
throw new ConcurrentModificationException();
if(!hasNext()){//如果当前已经在尾部,那么不可进行next()操作
throw new NoSuchElementException();
}
AnyType nextItem=current.data;
current=current.next;
okToRemove=true;
return nextItem;
}
public void remove(){
if(modCount!=expectedModCount){
throw new ConcurrentModificationException();
}
if(!okToRemove){//如果已经执行过删除,那么本次删除无效
throw new IllegalStateException();
}//调用MyLinkedList的删除函数,因为当前current已经向后移动过了,所以需要前移
MyLinkedList.this.remove(current.prex);
expectedModCount++;
okToRemove=false;
}
}
//测试
MyLinkedList<Integer> a=new MyLinkedList<>();
a.add(1);
a.add(2);
a.add(3);
a.add(1,4);
for(Integer s:a){//测试迭代器
System.out.print(s+",");
}
System.out.println();
System.out.println(a.size()+","+a.get(1));
a.remove(1);//删除
Iterator<Integer> t=a.iterator();
while(t.hasNext()){
if(t.next()==1)
t.remove();//用迭代器删除
}
for(Integer s:a){//测试迭代器
System.out.print(s+",");
}