java實現單項鍊表（複製，本身總結的在下一篇）

時間  2019-11-15
標籤 java 實現 單項 鏈表 複製 本身 總結 在下 一篇 欄目 Java 简体版
原文   原文鏈接
  1. 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. 2、內部實現。  
  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. 3、測試。。一個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. 4、所有代碼  
  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. }   
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程