關於逆轉鏈表

看到書裏關於讓鏈表逆序的方法，是從鏈表的尾巴開始把數據把數據複製到一新的鏈表上去，以此循環。對於鏈表這種線性結構來說，要訪問一個元素都要從頭遍歷。這個算法的效率絕對不好。是（n－1）！。

 

1. /**
2.      * p194 第四題
3.      * 逆序鏈表
4.      * @param source
5.      * @return
6.      */
7.     public static Node antitone(Node source){
8.         Node copyHead = null;
9.         Node copyTail = null;
10.         Node  temp;
11.         int n;
12.         if(source==null)
13.             return null;
14.         temp=source;
15.         
16.         n=listLength(source);
17.         System.out.println(n);
18.         for(int i=n-1;i>0;i--){
19.             temp=source;
20.             for(int j=0;j<i;j++){
21.                 temp=temp.link;
22.             }
23.             if(i==n-1){
24.                 copyHead=new Node(temp.data,null);
25.             copyTail=copyHead;}
26.             else{
27.             copyTail.addNodeAfter(temp.data);
28.             copyTail=copyTail.link;}
29.                 
30.         }
31.         return copyHead;
32.     }

我想了一個逆轉鏈表的算法，效率是線性的。只需遍歷每個節點。用一個指針保存一個節點,然後在下次循環中將下個節點指向前一個節點。

代碼如下：

1. /**
2.      * 逆轉鏈表
3.      * @param source
4.      * @return 原鏈表的尾指針,轉換後的頭指針
5.      */
6.     public static Node antitone(Node source){
7.         Node c1=null,c2=null;
8.         while(source!=null){
9.             c2=source.link; //要操作的節點
10.             source.link=c1;//指向前一個節點
11.             c1=source;//暫存的節點
12.             source=c2;//指向下一個節點,繼續循環
13.         }
14.         return c1;
15.      }