关于逆转链表

看到书里关于让链表逆序的方法，是从链表的尾巴开始把数据把数据复制到一新的链表上去，以此循环。对于链表这种线性结构来说，要访问一个元素都要从头遍历。这个算法的效率绝对不好。是（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.      }