链表用java实现简单单链表linkedlist

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

每个结点包括两个部分：

1是存储数据元素的数据域data

2是存储下一个结点地址的指针域p。

相比于线性表的优点：插入和删除结点方便。（插入删除的图都不画了，办公软件不好用）

这里是对单链表的理解，并用java的泛型实现，当然与java集合提供的API  LinkedList<E>还是有些不同的，在此只作为理解。

project

首先构造一个Node结点泛型类，结点里的数据类型是泛型E

public class Node<E> {
   E element;//元素
   Node<E> next; //指针
   public Node(E e){
	   element=e;
   }
}

MyAbstractList.java抽象类实现MyList.java,对接口部分实现，MyLinkedList.java继承 MyAbstractList.java抽象类
MyList.java

public interface MyList<E> {
  //添加一个元素
  public void add(E e);
  //在index处添加一个元素
  public void add(int index,E e);
  //清楚一个list列表
  public void clear();
  //删除一个元素
  public boolean remove(E e);
  //删除并返回index处的元素
  public E remove(int index);
  //index处的元素设置为元素e
  public Object set(int index,E e);
  //判断是否包含元素e
  public boolean contains(E e);
  //返回index处的元素
  public E get(int index);
  //返回列表中第一个与元素e匹配的下标index
  public int indexOf(E e);
  //返回列表中最后一个与元素e匹配的元素下标index
  public int lastIndeOf(E e);
  //判断列表是否为空
  public boolean isEmpty();
  //返回列表的大小
  public int size(); 
}

MyAbstractList.java

public abstract class MyAbstractList<E> implements MyList<E> {//部分实现MyList接口
    protected int size=0;  
	protected MyAbstractList(){
    	
    }
    protected MyAbstractList(E[] objects){
    	for(int i=1;i<objects.length;i++)
    	add(objects[i]);
    }
    @Override
    public void add(E e){
    	add(size,e);
    }
    @Override
    public void add(int index,E e){
    	
    }
    @Override
    public boolean isEmpty(){
    	return size==0;
    }
    @Override
    public int size(){
    	return size;
    }
    @Override
    public boolean remove(E e){
    	if(indexOf(e)>=0){
    		remove(indexOf(e));
    		return true;
    	}
    	else return false;
    }
    @Override
    public E remove(int index){
    	return null;
    }
    @Override
   	public void clear() {
   		// TODO Auto-generated method stub
   		
   	}
   	@Override
   	public Object set(int index, E e) {
   		// TODO Auto-generated method stub
   		return null;
   	}
   	@Override
   	public boolean contains(E e) {
   		// TODO Auto-generated method stub
   		return false;
   	}
   	@Override
   	public E get(int index) {
   		// TODO Auto-generated method stub
   		return null;
   	}
   	@Override
   	public int indexOf(E e) {
   		// TODO Auto-generated method stub
   		return 0;
   	}
   	@Override
   	public int lastIndeOf(E e) {
   		// TODO Auto-generated method stub
   		return 0;
   	}
}

MyLinkedList.java

public class MyLinkedList<E> extends MyAbstractList<E>{
       private Node<E> head,tail;
       public MyLinkedList(){    	   
       }
       public MyLinkedList(E[] objects){
    	   super(objects);
       }
       //返回头元素
       public E getFirst(){
    	   if(size==0){
    		   return null;
    	   }
    	   else{
    		   return head.element;
    	   }  		  
       }
       //返回尾元素
       public E getLast(){
    	   if(size==0){
    		   return null;
    	   }
    	   else{
    		   return tail.element;
    	   } 
       }
       //添加首元素
       public void addFirst(E e){
    	   Node<E> newNode=new Node<E>(e);
    	   newNode.next=head;
    	   head=newNode;
    	   size++;
    	   if(tail==null)
    		   tail=head;
       }
       //添加尾元素
       public void addLast(E e){
    	   Node<E> newNode=new Node<E>(e);
    	   if(tail==null){
    		   head=tail=newNode;
    	   }
    	   else{
    		   tail.next=newNode;
    		   tail=tail.next;
    	   }
    	   size++;
       }
       //在index处添加元素
       public void add(int index,E e){
    	   if(index==0) addFirst(e);
    	   else if(index>=size) addLast(e);
    	   else{
    		   Node<E> current=head;
    		   for(int i=1;i<index;i++)
    			   current=current.next;
    		   Node<E> temp=current.next;
    		   current.next=new Node<E>(e);
    		   (current.next).next=temp;
    		   size++;
    	   }
       }
       //删除并返回首元素
       public E removeFirst(){
    	   if(size==0)return null;
    	   else if(size==1){
    		   Node<E> temp=head;
    		   head=tail=null;
    		   size=0;
    		   return temp.element;
    	   }
    	   else{
    		   Node<E> temp=head;
    		   head=head.next;  		  
      		   size--;
    		   return temp.element;
    	   }
       }
       //删除并返回尾元素
       public E removeLast(){
    	   if(size==0)return null;
    	   else if(size==1){
    		   Node<E> temp=head;
    		   head=tail=null;
    		   size=0;
    		   return temp.element;
    	   }
    	   else{
    		   Node<E> current=head;
    		   for(int i=0;i<size-2;i++){
    			   current=current.next;
    		   }
    		   Node<E> temp=tail;
    		   tail=current;
    		   tail.next=null;
    		   size--;
    		   return temp.element;
    	   }
       }
       //删除并返回index处的元素
       public E remove(int index){
    	   if(index<0||index>=size) return null;
    	   else if(index==0) return removeFirst();
    	   else if(index==size-1) return removeLast();
    	   else{
    		   Node<E> previous=head;
    		   for(int i=1;i<index;i++){
    			   previous=previous.next;
    	   }
    		   Node<E> current=previous.next;
    		   previous.next=current.next;
    		   size--;
    		   return current.element;
       }
       }
       public String toString(){
    	   StringBuilder result=new StringBuilder("[");
    	   Node<E> current=head;
   		for(int i=0;i<size;i++){
   			result.append(current.element);
   			current=current.next;
   			if(current!=null){
   				result.append(",");
   			}
   			else{
   				result.append("]");
   			}  			
   		}
   		return result.toString();
       }
       public void clear(){
    	   head=tail=null;
       }
       //是否包含元素e
       public boolean contains(E e){
    	  Node<E> current=head;
          for(int i=0;i<size;i++){
    	  if(current.element.equals(e)){
    			return true;
    	      }
    	  else{
    		   current=current.next;
    		   }
    	  }    	  
    	 return false;
       }
       //返回index处的元素
       public E get(int index){//index都是从0 算起的，size是从1算起的
    	   if(index<0||index>=size) return null;
    	   else if(index==0) return head.element;
    	   else if(index==size-1) return tail.element;
    	   else{
    		   Node<E> current=head;
    		   for(int i=1;i<index;i++)
    			   current=current.next;
    		   Node<E> temp=current.next;
    		   return temp.element;
    	   }   	   
       }
       public int indexOf(E e){
    	   if(size==0) return -1;
    	   else {
    		   Node<E> current=head;
    		   for(int i=0;i<size;i++){
    			   if(current.element.equals(e))
    				   return i;
    			   else current=current.next;
    		   }  			   
    	   }
    	   return -1;
       }
       public int lastIndexOf(E e){
    	   if(size==0) return -1;
    	   else {
    		   Node<E> current=tail;
    		   for(int i=size-1;i>=0;i--){
    			   if(current.element.equals(e))
    				   return i;
    			   else current=current.next;
    		   }  			   
    	   }
    	   return -1;
       }
       //在index处的元素设置为e
       public E set(int index,E e){
    	   if(index<0||index>=size) return null;
    	   else{
    		   Node<E> current=head;
    		   for(int i=1;i<index;i++)
    			   current=current.next;
    		   Node<E> old=current.next;
    		    E oldE=old.element;
    		    old.element=e;
    		   return oldE;    		
    	   }
       }
}

TestMyLinkedList.java

public class TestMyLinkedList {
	public static void main(String[] args) {
		
		MyList<String> list=new MyLinkedList<>();
	       list.add("America");
	       System.out.println("(1)"+list);
	       
	       list.add(0,"Canada");
	       System.out.println("(2)"+list);
	       
	       list.add("Russia");
	       System.out.println("(3)"+list);
	       
	       list.add("France");
	       System.out.println("(4)"+list);
	       
	       list.add(2,"Gemany");//在索引2的位置插入
	       System.out.println("(5)"+list);
	       
	       list.add(5,"Norway");//在索引5的位置插入
	       System.out.println("(6)"+list);
	       
	       list.remove("Canada");//移出
	       System.out.println("(7)"+list);
	       
	       list.remove("2");//移出索引2的元素
	       System.out.println("(8)"+list);
	       
	       list.remove(list.size()-1);
	       System.out.println("(9)"+list);
	}

}

测试结果：

(1)[America]
(2)[Canada,America]
(3)[Canada,America,Russia]
(4)[Canada,America,Russia,France]
(5)[Canada,America,Gemany,Russia,France]
(6)[Canada,America,Gemany,Russia,France,Norway]
(7)[America,Gemany,Russia,France,Norway]
(8)[America,Gemany,Russia,France,Norway]
(9)[America,Gemany,Russia,France]