自己实现单向链表讨论一下LinkedList的效率

不知道大家有没有试过这样去遍历一个LinkedList

[java] view plain copy

1. for(int i=0;i<list.size();i++){  
2. list.get(i);  
3. }  

   我以前就是这样做的，不是不知道有iterator 这个方法，而是习惯了。

   到不久前自己用JAVA去重写数所据结构的实现才发现一些东西。

   像用Itertate 比用for循环快，究单竟快多少呢？

   下面我用自己写的例子说一点个人见解：

   List 的结点：

   [java] view plain copy

   1. package com.shmilyhe.data;  
   2.   
   3. public class Node<T> {  
   4. public T content;  
   5. public Node<T> next;  
   6. public Node(){}  
   7. public Node(T value){  
   8.     content=value;  
   9. }  
   10. }  

   链表（LinkedList 是双向链表，为了简单我只写了个单向的，测试迭代效果是一样的）

   [java] view plain copy

   1. package com.shmilyhe.data;  
   2.   
   3.   
   4. public class SinglyLinked<T> {  
   5.     private Node<T> current;  
   6.     private Node<T> head;  
   7.     private Node<T>end;  
   8.     private int count;  
   9.     public T next(){  
   10.           
   11.         T t=current==null?null:current.content;  
   12.         current=current==null?null:current.next;  
   13.         return t;  
   14.     }  
   15.     public void reSet(){  
   16.         current=head;  
   17.     }  
   18.     public void remove(int index){  
   19.         Node<T> node=head;  
   20.     for(int i=0;i<index;i++){  
   21.         node=node==null?null:node.next;  
   22.     }  
   23.     if(node!=null)node.next=node.next==null?null:node.next.next;  
   24.     }  
   25.     public int length(){  
   26.         return count;  
   27.     }  
   28.     public T get(int index){  
   29.         Node<T>node=head;  
   30.         for(int i=0;i<index;i++){  
   31.             node=node==null?null:node.next;  
   32.         }  
   33.         return node==null?null:node.content;  
   34.     }  
   35.     public void removeAll(){  
   36.         current=null;  
   37.         head=null;  
   38.         count=0;  
   39.     }  
   40.     public void add(T value){  
   41.         if(head==null){  
   42.             head=new Node<T>();  
   43.             head.content=value;  
   44.             end=head;  
   45.             current=head;  
   46.         }else{  
   47.             end.next=new Node<T>(value);  
   48.             end=end.next;  
   49.         }  
   50.         count++;  
   51.           
   52.     }  
   53.     public Object[] toArray(){  
   54.         Object[] array=new Object[this.count];  
   55.         T t=null;  
   56.         int flag=0;  
   57.         while((t=this.next())!=null){  
   58.             array[flag]=t;  
   59.             flag++;  
   60.         }  
   61.         return array;  
   62.     }  
   63. }  

   由上面可知：

   迭代遍历List 时间复杂度为T(n)=O (n)

   而用for 循环则 T(n)=O(n*n+n/2)

   for 循环遍历 用的时间是 迭代的(n+1)/2倍即list越大效率相差越大

   事实是不是这样呢？

   下面是我写的SinglyLinked 和JAVA 自带的LinkedList的测试，结果正如我所想

   [java] view plain copy

   1. package com.shmilyhe.test;  
   2.   
   3.   
   4.   
   5. import java.util.Date;  
   6. import java.util.Iterator;  
   7. import java.util.LinkedList;  
   8.   
   9. import org.junit.Test;  
   10.   
   11. import com.shmilyhe.data.SinglyLinked;  
   12.   
   13. public class SinglyLinkedTest {  
   14.     @Test  
   15.     public void testIterator(){  
   16.         SinglyLinked sl=new SinglyLinked();  
   17.         for(int i=0;i<100000;i++){  
   18.             sl.add(""+i);  
   19.         }  
   20.         Object tem=null;  
   21.         Date bt=new Date();  
   22.         while((tem=sl.next())!=null){  
   23.               
   24.             System.out.println(tem);  
   25.         }  
   26.         Date et=new Date();  
   27.         System.out.println(bt+"/n");  
   28.         System.out.println(et+"/n");  
   29.         System.out.println("迭代所用的时间为（MS）："+(et.getTime()-bt.getTime()));  
   30.     }  
   31.     @Test  
   32.     public void testFor(){  
   33.         SinglyLinked sl=new SinglyLinked();  
   34.         for(int i=0;i<100000;i++){  
   35.             sl.add(""+i);  
   36.         }  
   37.         Date bt=new Date();  
   38.         for(int i=0;i<sl.length();i++){  
   39.             System.out.println(sl.get(i));  
   40.         }  
   41.         Date et=new Date();  
   42.         System.out.println(bt+"/n");  
   43.         System.out.println(et+"/n");  
   44.         System.out.println("for循环遍历所用的时间为（MS）："+(et.getTime()-bt.getTime()));  
   45.     }  
   46.     @Test  
   47.     public void testGenericsIterator(){  
   48.         SinglyLinked<String> sl=new SinglyLinked<String>();  
   49.         for(int i=0;i<100000;i++){  
   50.             sl.add(""+i);  
   51.         }  
   52.         String tem=null;  
   53.         Date bt=new Date();  
   54.         while((tem=sl.next())!=null){  
   55.               
   56.             System.out.println(tem);  
   57.         }  
   58.         Date et=new Date();  
   59.         System.out.println(bt+"/n");  
   60.         System.out.println(et+"/n");  
   61.         System.out.println("泛型迭代所用的时间为（MS）："+(et.getTime()-bt.getTime()));  
   62.     }  
   63.     @Test  
   64.     public void testLinkedListItorate(){  
   65.         LinkedList ll=new LinkedList();  
   66.         for(int i=0;i<100000;i++){  
   67.             ll.add(""+i);  
   68.         }  
   69.         Iterator it =ll.iterator();  
   70.         Date bt=new Date();  
   71.         while(it.hasNext()){  
   72.             System.out.println(it.next());  
   73.         }  
   74.         Date et=new Date();  
   75.         System.out.println(bt+"/n");  
   76.         System.out.println(et+"/n");  
   77.         System.out.println("LinkedList迭代所用的时间为（MS）："+(et.getTime()-bt.getTime()));  
   78.     }  
   79.     @Test  
   80.     public void testLinkedListFor(){  
   81.         LinkedList ll=new LinkedList();  
   82.         for(int i=0;i<100000;i++){  
   83.             ll.add(""+i);  
   84.         }  
   85.         Date bt=new Date();  
   86.         for(int i=0;i<ll.size();i++){  
   87.             System.out.println(ll.get(i));  
   88.         }  
   89.         Date et=new Date();  
   90.         System.out.println(bt+"/n");  
   91.         System.out.println(et+"/n");  
   92.         System.out.println("for循环遍历LinkedList所用的时间为（MS）："+(et.getTime()-bt.getTime()));  
   93.     }  
   94. } 
       

4.