java实现单项链表（复制，自己总结的在下一篇）

  1. 一、单向链表的结构。  
  2.   
  3.      (1)、首先节点的结构，其中包含本节点内容，以及需要指向下一个节点。   
  4.   
  5.   
  6. Java代码    
  7. private static class Entry<E>{     
  8.         E e;     
  9.         Entry<E> nextEntry;     
  10.               
  11.         public Entry(E e,Entry<E> nextEntry){     
  12.             this.e=e;     
  13.             this.nextEntry=nextEntry;     
  14.         }     
  15.     }    
  16.   
  17. private static class Entry<E>{  
  18.         E e;  
  19.         Entry<E> nextEntry;  
  20.            
  21.         public Entry(E e,Entry<E> nextEntry){  
  22.             this.e=e;  
  23.             this.nextEntry=nextEntry;  
  24.         }  
  25.     }Java代码    
  26.     
  27.   
  28.   
  29. Java代码    
  30.     
  31.   
  32.  其中e则指向本节点的对象，而nextEntry则指向下一个节点。  
  33.   
  34.    
  35.   
  36.      (2)、任何时候都需要知道表头在哪里。毕竟是单向链表嘛，因为只有一个方向，找到了表头就能找到全部。          
  37.   
  38. Java代码    
  39. private  Entry<E> head;    
  40.   
  41. private  Entry<E> head;   
  42.   
  43.      (3)、还可以记录链表中总共有多少个节点。它是在某些判断时为了提高效率而存在的。不是绝对需要的。毕竟知道表头后，一个一个按顺序去寻找就好了。  
  44.   
  45.   
  46. Java代码    
  47. private  int size;     
  48.     
  49. public int size(){     
  50.         return this.size;     
  51.     }    
  52.   
  53. private  int size;  
  54.   
  55. public int size(){  
  56.         return this.size;  
  57.     }  
  58. Java代码    
  59.     
  60.   
  61.     好了有这三样，就足够了。就看我们如何用他们了。  
  62.   
  63.    
  64.   
  65. 二、内部实现。  
  66.   
  67.     (1)、第一次向链表中插入。此时链表中节点为null，第一次插入，无非就是把节点头插入而已。   
  68.   
  69. 可以看出就是把链表头初始化了，并且链表大小涨1。其中modCount记录整个链表修改的次数，链表的增加和删除它都会增加。毕竟第一次插入相对外调用是透明的，所以应该是私有的咯。（透明就是不可见，这里只得是外部没必要知道它的存在）  
  70.   
  71. Java代码    
  72. private void addFirst(E e){     
  73.         head=new Entry<E>(e,null);     
  74.         size++;     
  75.         modCount++;     
  76.     }    
  77.   
  78. private void addFirst(E e){  
  79.         head=new Entry<E>(e,null);  
  80.         size++;  
  81.         modCount++;  
  82.     }   
  83.   
  84.     (2)、表头插入。在链表的头前插入一个元素，新增的元素变成新的表头。这个插入是效率最高的，毕竟你时刻知道链表的头在哪里。  
  85.   
  86. Java代码    
  87. public void addHead(E e){     
  88.         if(head==null){     
  89.             this.addFirst(e);     
  90.         }else{     
  91.             Entry<E> newEntry=new Entry<E>(e,head);     
  92.             head=newEntry;     
  93.             size++;     
  94.             modCount++;     
  95.         }     
  96.     }    
  97.   
  98. public void addHead(E e){  
  99.         if(head==null){  
  100.             this.addFirst(e);  
  101.         }else{  
  102.             Entry<E> newEntry=new Entry<E>(e,head);  
  103.             head=newEntry;  
  104.             size++;  
  105.             modCount++;  
  106.         }  
  107.     }可以看出头为null的时候，则表明链表中没值，只需调用第一次插入。否则对给定的元素创新增一个节点，新增节点的下一个指向头节点，当然此时自己已经变成头结点了，索引要更新头节点的引用。（可以看出想要清空链表，只需要将头置为null就好了）  
  108.   
  109.    
  110.   
  111.    (3)、指定节点插入（插队）。在链表的指定节点插入一个元素，效率非常低。由于规则上你只能从队伍第一个开始往后找，找到你要插队位置的前一个，并将你插入其中，你先要告诉你身前人你在他身后，并且你自己要清楚你身后是谁。反正够麻烦的。  
  112.   
  113.   
  114. Java代码    
  115. public void addSpecifyIndex(E e,int index){     
  116.         if(index<0||index>size||size==0){     
  117.             throw new NoSuchElementException();     
  118.         }     
  119.         if(index==0){     
  120.             this.addHead(e);     
  121.             return;     
  122.         }     
  123.         int count=0;     
  124.         for (Entry<E> p=head; p!=null;p=p.nextEntry) {     
  125.             if(count+1==index){     
  126.                 Entry<E> newEntry=new Entry<E>(e,p.nextEntry);     
  127.                 p.nextEntry=newEntry;     
  128.                 size++;     
  129.                 modCount++;     
  130.                 return;     
  131.             }     
  132.             count++;     
  133.         }     
  134.     }    
  135.   
  136. public void addSpecifyIndex(E e,int index){  
  137.         if(index<0||index>size||size==0){  
  138.             throw new NoSuchElementException();  
  139.         }  
  140.         if(index==0){  
  141.             this.addHead(e);  
  142.             return;  
  143.         }  
  144.         int count=0;  
  145.         for (Entry<E> p=head; p!=null;p=p.nextEntry) {  
  146.             if(count+1==index){  
  147.                 Entry<E> newEntry=new Entry<E>(e,p.nextEntry);  
  148.                 p.nextEntry=newEntry;  
  149.                 size++;  
  150.                 modCount++;  
  151.                 return;  
  152.             }  
  153.             count++;  
  154.         }  
  155.     }  
  156. Java代码    
  157.     
  158.   
  159. 先进行判断index是否正确，规定不能插入null链表。而且不能跳着走，毕竟链表要连起来。由于要找到前一个，但是表头的前一个是没有的，所以index==0时要单独判断。后面则用count进行计数，找到其index-1节点，然后进行插队处理。  
  160.   
  161.    
  162.   
  163.     (4)、尾插入。其实也是插队了，只是总是需要插到最后一个之后。  
  164.   
  165. Java代码    
  166. public void add(E e){     
  167.         if(head==null){     
  168.             this.addFirst(e);     
  169.         }else{     
  170.             this.addSpecifyIndex(e, size);     
  171.         }     
  172.     }    
  173.   
  174. public void add(E e){  
  175.         if(head==null){  
  176.             this.addFirst(e);  
  177.         }else{  
  178.             this.addSpecifyIndex(e, size);  
  179.         }  
  180.     }   
  181.   
  182.     (5)、指定节点获取元素。效率低，同样从头开始找到指定的节点把其中元素取出  
  183.   
  184.   
  185. Java代码    
  186. public E get(int index){     
  187.         if(index<0||index>=size){     
  188.             throw new NoSuchElementException();     
  189.         }     
  190.         E result=null;     
  191.         int count=0;     
  192.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {     
  193.             if(count==index){     
  194.                 result=p.e;     
  195.             }     
  196.             count++;     
  197.         }     
  198.         return result;     
  199.     }    
  200.   
  201. public E get(int index){  
  202.         if(index<0||index>=size){  
  203.             throw new NoSuchElementException();  
  204.         }  
  205.         E result=null;  
  206.         int count=0;  
  207.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {  
  208.             if(count==index){  
  209.                 result=p.e;  
  210.             }  
  211.             count++;  
  212.         }  
  213.         return result;  
  214.     }  
  215. Java代码    
  216.     
  217.   
  218.    
  219.   
  220.     (6)、指定节点删除。效率低，同样需要找到指定节点前一节点，直接把指定节点跳过就好了。  
  221.   
  222. Java代码    
  223. public void remove(int index){     
  224.         if(index<0||index>=size){     
  225.             throw new NoSuchElementException();     
  226.         }     
  227.         if(index==0){     
  228.             head=head.nextEntry;     
  229.             size--;     
  230.             modCount++;     
  231.             return;     
  232.         }     
  233.         int count=0;     
  234.         for (Entry<E> p=head;p.nextEntry!=null;p=p.nextEntry) {     
  235.             if(count+1==index){     
  236.                 p.nextEntry=p.nextEntry.nextEntry;     
  237.                 size--;     
  238.                 modCount++;     
  239.                 break;     
  240.             }     
  241.             count++;     
  242.         }     
  243.     }    
  244.   
  245. public void remove(int index){  
  246.         if(index<0||index>=size){  
  247.             throw new NoSuchElementException();  
  248.         }  
  249.         if(index==0){  
  250.             head=head.nextEntry;  
  251.             size--;  
  252.             modCount++;  
  253.             return;  
  254.         }  
  255.         int count=0;  
  256.         for (Entry<E> p=head;p.nextEntry!=null;p=p.nextEntry) {  
  257.             if(count+1==index){  
  258.                 p.nextEntry=p.nextEntry.nextEntry;  
  259.                 size--;  
  260.                 modCount++;  
  261.                 break;  
  262.             }  
  263.             count++;  
  264.         }  
  265.     }   
  266.   
  267.    (7)、循环。为了好进行遍历演示，下面的就是循环遍历所用的了，大家随意看一下就好了。  
  268.   
  269.    
  270.   
  271. Java代码    
  272. private transient Entry<E> current;     
  273.     
  274. public void setCursor(int index){     
  275.         if(index<0||index>=size){     
  276.             throw new NoSuchElementException();     
  277.         }     
  278.         int count=0;     
  279.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {     
  280.             if(count==index){     
  281.                 current=p;     
  282.                 break;     
  283.             }     
  284.             count++;     
  285.         }     
  286.     }     
  287.          
  288.     public boolean hasNext(){     
  289.         return current!=null;     
  290.     }     
  291.          
  292.     public E next(){     
  293.         E result=current.e;     
  294.         current=current.nextEntry;     
  295.         return result;     
  296.     }    
  297.   
  298. private transient Entry<E> current;  
  299.   
  300. public void setCursor(int index){  
  301.         if(index<0||index>=size){  
  302.             throw new NoSuchElementException();  
  303.         }  
  304.         int count=0;  
  305.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {  
  306.             if(count==index){  
  307.                 current=p;  
  308.                 break;  
  309.             }  
  310.             count++;  
  311.         }  
  312.     }  
  313.       
  314.     public boolean hasNext(){  
  315.         return current!=null;  
  316.     }  
  317.       
  318.     public E next(){  
  319.         E result=current.e;  
  320.         current=current.nextEntry;  
  321.         return result;  
  322.     }   
  323.   
  324. 三、测试。。一个main方法，测试一下。  
  325.   
  326. Java代码    
  327. public static void main(String[] args) {     
  328.         SingleChain<String> singleChain=new SingleChain<String>();     
  329.         for (int i = 0; i < 4; i++) {     
  330.             singleChain.add(i+"");     
  331.         }     
  332.         //头插入     
  333. //      singleChain.addHead("head");     
  334.         //尾插入     
  335. //      singleChain.add("tail");     
  336.         //指定节点插入     
  337. //      singleChain.addSpecifyIndex("Specify", 1);     
  338.         //指定节点删除     
  339. //      singleChain.remove(3);     
  340.         //设置循环的初始节点     
  341.         singleChain.setCursor(0);     
  342.         int count=0;     
  343.         System.out.println("######SIZE"+singleChain.size()+"#######");     
  344.         while(singleChain.hasNext()){     
  345.             System.out.println("index:"+count+",entry:"+singleChain.next());     
  346.             count++;     
  347.         }     
  348.              
  349.         System.out.println(singleChain.get(singleChain.size()-1));     
  350.     }    
  351.   
  352. public static void main(String[] args) {  
  353.         SingleChain<String> singleChain=new SingleChain<String>();  
  354.         for (int i = 0; i < 4; i++) {  
  355.             singleChain.add(i+"");  
  356.         }  
  357.         //头插入  
  358. //      singleChain.addHead("head");  
  359.         //尾插入  
  360. //      singleChain.add("tail");  
  361.         //指定节点插入  
  362. //      singleChain.addSpecifyIndex("Specify", 1);  
  363.         //指定节点删除  
  364. //      singleChain.remove(3);  
  365.         //设置循环的初始节点  
  366.         singleChain.setCursor(0);  
  367.         int count=0;  
  368.         System.out.println("######SIZE"+singleChain.size()+"#######");  
  369.         while(singleChain.hasNext()){  
  370.             System.out.println("index:"+count+",entry:"+singleChain.next());  
  371.             count++;  
  372.         }  
  373.           
  374.         System.out.println(singleChain.get(singleChain.size()-1));  
  375.     }   
  376.   
  377.    
  378.   
  379. 四、全部代码  
  380.   
  381.    
  382.   
  383. Java代码    
  384. package paladin.chain;     
  385.     
  386. import java.util.NoSuchElementException;     
  387.     
  388. public class SingleChain<E> implements Chain<E>{     
  389.          
  390.     private  Entry<E> head;     
  391.          
  392.     private transient Entry<E> current;     
  393.          
  394.     private  int size;     
  395.          
  396.     private  int modCount;     
  397.          
  398.          
  399.     private void addFirst(E e){     
  400.         head=new Entry<E>(e,null);     
  401.         size++;     
  402.         modCount++;     
  403.     }     
  404.          
  405.     public void addHead(E e){     
  406.         if(head==null){     
  407.             this.addFirst(e);     
  408.         }else{     
  409.             Entry<E> newEntry=new Entry<E>(e,head);     
  410.             head=newEntry;     
  411.             size++;     
  412.             modCount++;     
  413.         }     
  414.     }     
  415.          
  416.     public void addSpecifyIndex(E e,int index){     
  417.         if(index<0||index>size||size==0){     
  418.             throw new NoSuchElementException();     
  419.         }     
  420.         if(index==0){     
  421.             this.addHead(e);     
  422.             return;     
  423.         }     
  424.         int count=0;     
  425.         for (Entry<E> p=head; p!=null;p=p.nextEntry) {     
  426.             if(count+1==index){     
  427.                 Entry<E> newEntry=new Entry<E>(e,p.nextEntry);     
  428.                 p.nextEntry=newEntry;     
  429.                 size++;     
  430.                 modCount++;     
  431.                 return;     
  432.             }     
  433.             count++;     
  434.         }     
  435.     }     
  436.          
  437.     public void add(E e){     
  438.         if(head==null){     
  439.             this.addFirst(e);     
  440.         }else{     
  441.             this.addSpecifyIndex(e, size);     
  442.         }     
  443.     }     
  444.          
  445.     public E get(int index){     
  446.         if(index<0||index>=size){     
  447.             throw new NoSuchElementException();     
  448.         }     
  449.         E result=null;     
  450.         int count=0;     
  451.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {     
  452.             if(count==index){     
  453.                 result=p.e;     
  454.             }     
  455.             count++;     
  456.         }     
  457.         return result;     
  458.     }     
  459.          
  460.     public void remove(int index){     
  461.         if(index<0||index>=size){     
  462.             throw new NoSuchElementException();     
  463.         }     
  464.         if(index==0){     
  465.             head=head.nextEntry;     
  466.             size--;     
  467.             modCount++;     
  468.             return;     
  469.         }     
  470.         int count=0;     
  471.         for (Entry<E> p=head;p.nextEntry!=null;p=p.nextEntry) {     
  472.             if(count+1==index){     
  473.                 p.nextEntry=p.nextEntry.nextEntry;     
  474.                 size--;     
  475.                 modCount++;     
  476.                 break;     
  477.             }     
  478.             count++;     
  479.         }     
  480.     }     
  481.          
  482.     public void setCursor(int index){     
  483.         if(index<0||index>=size){     
  484.             throw new NoSuchElementException();     
  485.         }     
  486.         int count=0;     
  487.         for (Entry<E> p=head;p!=null;p=p.nextEntry) {     
  488.             if(count==index){     
  489.                 current=p;     
  490.                 break;     
  491.             }     
  492.             count++;     
  493.         }     
  494.     }     
  495.          
  496.     public boolean hasNext(){     
  497.         return current!=null;     
  498.     }     
  499.          
  500.     public E next(){     
  501.         E result=current.e;     
  502.         current=current.nextEntry;     
  503.         return result;     
  504.     }     
  505.          
  506.     public int size(){     
  507.         return this.size;     
  508.     }     
  509.          
  510.     public static void main(String[] args) {     
  511.         SingleChain<String> singleChain=new SingleChain<String>();     
  512.         for (int i = 0; i < 4; i++) {     
  513.             singleChain.add(i+"");     
  514.         }     
  515.         //头插入     
  516. //      singleChain.addHead("head");     
  517.         //尾插入     
  518. //      singleChain.add("tail");     
  519.         //指定节点插入     
  520. //      singleChain.addSpecifyIndex("Specify", 1);     
  521.         //指定节点删除     
  522. //      singleChain.remove(3);     
  523.         //设置循环的初始节点     
  524.         singleChain.setCursor(0);     
  525.         int count=0;     
  526.         System.out.println("######SIZE"+singleChain.size()+"#######");     
  527.         while(singleChain.hasNext()){     
  528.             System.out.println("index:"+count+",entry:"+singleChain.next());     
  529.             count++;     
  530.         }     
  531.              
  532.         System.out.println(singleChain.get(singleChain.size()-1));     
  533.     }     
  534.          
  535.     private static class Entry<E>{     
  536.         E e;     
  537.         Entry<E> nextEntry;     
  538.               
  539.         public Entry(E e,Entry<E> nextEntry){     
  540.             this.e=e;     
  541.             this.nextEntry=nextEntry;     
  542.         }     
  543.     }     
  544. }   
posted @ 2014-11-04 16:33  夜未央T  阅读(2430)  评论(0)  编辑  收藏  举报