反正打印链表

开始看这个题目的时候，还真觉得他娘的高大上啊。

其实呢，都是些噱头！！！！！

两种方法：

    1、用栈实现

    2、既然能想到栈，那么递归也能想到吧

比较两种方法：

     比较这两种方法而言，其实用栈的方法好些，对于递归这种方法，如果链表过长，（我们知道，对于子函数的调用，是通过不断地在主函数体后面的空间

中组织新的栈空间），因此可能会导致栈的溢出。

用栈实现：

#ifndef LIST_INSERTREMOVEPRINT_H
#define LIST_INSERTREMOVEPRINT_H
#include<iostream>
#include<stack>
struct ListNode{
	int val; 
	struct ListNode *nxt;
}; 
void addListNode(struct ListNode**list,int value){
	struct ListNode *nodeInsert=(struct ListNode*)(malloc(sizeof(struct ListNode))); 
	nodeInsert->val=value; 
	nodeInsert->nxt=NULL; 
	if(*list==NULL){
		*list=nodeInsert;
		return ; 
	}
	struct ListNode *iter=*list; 
	while(iter->nxt!=NULL){
		iter=iter->nxt; 
	}
	iter->nxt=nodeInsert; 
}
void removeListNode(struct ListNode**head,int value){
	if(*head==NULL||head==NULL){
		return ; 
	}
	struct ListNode *deleteNode=NULL; 
	if((*head)->val==value){
		deleteNode=*head; 
		(*head)=(*head)->nxt; 
		delete deleteNode; 
		return; 
	}
	struct ListNode *pnode=*head; 
	while(pnode!=NULL){
		pnode=pnode->nxt; 
		if(pnode->val==value){
			deleteNode=pnode; 
			pnode=pnode->nxt; 
			delete deleteNode; 
			return ; 
		}
	}
}
void invertPrint(struct ListNode**head){	
	if(head==NULL||*head==NULL){
		return; 
	}else{
		struct ListNode *iter=*head; 
		std::stack<int> listStack; 
		while(iter!=NULL){
			listStack.push(iter->val);
			iter=iter->nxt; 
		}
		while(!listStack.empty()){
			std::cout<<listStack.top(); 
			listStack.pop(); 
		}
		return ; 
	}
}
#endif 

测试代码：

int main(){
	struct ListNode *list=NULL; 
	addListNode(&list,2);
	addListNode(&list,3); 
	addListNode(&list,4); 
	invertPrint(&list);	
}

用递归实现：

void invertPrint_recursive(struct ListNode*head){
	if(head==NULL){
		return ; 
	}else{
		if(head->nxt!=NULL){
			 invertPrint_recursive(head->nxt); 
		}
		std::cout<<head->val<<std::endl; 
	}
｝

来自为知笔记(Wiz)