三种方式实现--从尾到头输出链表

 三种方式实现--从尾到头输出链表

　   方法一：借用栈倒序输出链表

　　方法二：先翻转链表，再顺序输出

　　方法三：递归实现，一个妙，两个字妙啊

　　方法一：借用栈倒序输出链表
  　　　　　 因为栈是先进后出，把链表中的元素存进栈中，链表前面的元素在栈底，后面的元素在栈顶，链表后面的元素先出栈

　　方法二：先翻转链表，再按顺序打印（主要是想自己实现单链表的翻转，这种实现方式破坏了链表的结构，当然再翻转一下就还原了）
                 翻转链表的步骤：
                      1:将当前节点的next节点指向他以前的前一个节点
                      2:当前节点下移一位
                      3:如果是最后一个节点，就把它的next节点指向它以前的前一个节点，并推出循环

　　方法三：用递归实现
                 很诚实的说盗用了别人的思想，真的太妙了，完全能看出你是否真的体会了递归的原理
                 正如那位哥们所说，递归就是一个进栈出栈的过程，链表前面的元素先进栈，在栈底，后面的元素后进栈，在栈顶，先出栈，哈哈。。。

 

[cpp] view plain copy print ?

1. //三种方式实现--从尾到头输出链表  
2. #include <stack>  
3. using namespace std;  
4.   
5. class OutFromEnd  
6. {  
7.     public:  
8.         typedef struct node1  
9.         {  
10.             int data;  
11.             node1* next;  
12.             node1(int d):data(d),next(NULL){}  
13.         } node;  
14.   
15.         OutFromEnd()  
16.         {  
17.             head=cur=new node(-1);  
18.         }  
19.   
20.         void add(int data)  
21.         {  
22.             node* tmp=new node(data);  
23.             cur->next=tmp;  
24.             cur=tmp;  
25.         }  
26.   
27.         //借用栈倒序输出链表  
28.         //因为栈是先进后出，把链表中的元素存进栈中，链表前面的元素在栈底，后面的元素在栈顶，链表后面的元素先出栈  
29.         void stackMethod()  
30.         {  
31.             if(NULL==head || NULL==head->next)  
32.             {  
33.                 return;  
34.             }  
35.    
36.             node* tmp=head->next;  
37.             stack<int> s;  
38.                
39.             while(tmp!=NULL)  
40.             {  
41.                 s.push(tmp->data);  
42.                 tmp=tmp->next;  
43.             }  
44.   
45.             while(!s.empty())  
46.             {  
47.                 cout<<s.top()<<"\t";  
48.                 s.pop();  
49.             }  
50.         }  
51.   
52.         /* 
53.             先翻转链表，再按顺序打印（主要是想自己实现单链表的翻转，这种实现方式破坏了链表的结构，当然再翻转一下就还原了） 
54.             翻转链表的步骤： 
55.                 1:将当前节点的next节点指向他以前的前一个节点 
56.                 2:当前节点下移一位 
57.                 3:如果是最后一个节点，就把它的next节点指向它以前的前一个节点，并推出循环 
58.         */  
59.         void reverse()  
60.         {  
61.             if(NULL==head || NULL==head->next)  
62.             {  
63.                 return;  
64.             }  
65.             cur=head->next;  
66.   
67.             node* prev=NULL;  
68.             node* pcur=head->next;  
69.             node* next;  
70.             while(pcur!=NULL)  
71.             {  
72.                 if(pcur->next==NULL)  
73.                 {  
74.                     pcur->next=prev;  
75.                     break;  
76.                 }  
77.                 next=pcur->next;  
78.                 pcur->next=prev;  
79.                 prev=pcur;  
80.                 pcur=next;  
81.             }  
82.   
83.             head->next=pcur;  
84.                
85.             node* tmp=head->next;  
86.             while(tmp!=NULL)  
87.             {  
88.                 cout<<tmp->data<<"\t";  
89.                 tmp=tmp->next;  
90.             }  
91.         }  
92.   
93.         void print3()  
94.         {  
95.             recursion(head->next);  
96.         }  
97.   
98.         //用递归实现  
99.         //很诚实的说盗用了别人的思想，真的太妙了，完全能看出你是否真的体会了递归的原理  
100.         //正如那位哥们所说，递归就是一个进栈出栈的过程，链表前面的元素先进栈，在栈底，后面的元素后进栈，在栈顶，先出栈，哈哈。。。  
101.         void recursion(node* head)  
102.         {  
103.             if(NULL==head)  
104.             {  
105.                 return;  
106.             }  
107.   
108.             if(head->next!=NULL)  
109.             {  
110.                 recursion(head->next);  
111.             }  
112.   
113.             //如果把这句放在第二个if前面，那就是从头到尾输出链表，曾经的你或许是用while或者用for循环输出链表，现在你又多了一种方式  
114.             cout<<head->data<<"\t";  
115.         }  
116.   
117.     private :  
118.         node *head,*cur;  
119. };