面试题5-从尾到头打印链表

题目：

输入一个链表的头节点，从尾到头反过来打印出每个结点的值。

在看这个题目之前，首先来回顾一下链表的插入与删除操作。注意这里的插入和删除和数据结构中学的稍有差异，这里的链表是不带头结点的（即第一个节点就是数据节点）。

先来看一段代码：

#include <iostream>
using namespace std;
struct ListNode
{
	int m_pData;
	struct ListNode *m_pNext;
};
void AddToTail(ListNode *pHead, int value)
{
	ListNode *pNew = new ListNode();
	pNew->m_pData = value;
	pNew->m_pNext = NULL;

	if(pHead == NULL)
	{
		cout<<"======"<<endl;
		pHead = pNew;
	}
	else
	{
		ListNode *pNode = pHead;
		while(pNode->m_pNext != NULL)
		{
			pNode = pNode->m_pNext;
		}

		pNode->m_pNext = pNew;
	}
}
int main()
{
	ListNode *pHead = NULL;
	AddToTail(pHead, 14);
	cout<<pHead->m_pData<<endl;
	return 0;
}

这是一段简单的代码，但是这段代码是错误的，因为当pHead为NULL的时候，在函数AddToTail中改变了pHead的值，但是函数的参数只是链表的头结点的指针，main函数只能感应到*pHead的改变，但是感应不到pHead的改变，这段代码的错误再用pHead在函数内部发生了改变，这个改变却没有被带回到main函数。因此，在main函数中打印pHead->m_pData这行代码会报错，因为你的pHead指针指向的还是NULL。

对于这个错误，我想出了三种方式来解决

（1）使用指针的指针做函数的参数

（2）使用返回值，将变化的指针返回即可

（3）使用引用，简单且有效

具体细节见代码：（代码中带有一段，删除节点的操作）

#include <iostream>
using namespace std;

struct LinkNode
{
	int m_pData;
	struct LinkNode *m_pNext;
};

//1.使用指针的指针来返回链表的更新
void AddToTail(LinkNode **pHead, int value)
{
	LinkNode *pNew = new LinkNode();
	pNew->m_pData = value;
	pNew->m_pNext = NULL;

	if(*pHead == NULL)
	{
		*pHead = pNew;
	}
	else
	{
		LinkNode *pNode = *pHead;
		while(pNode->m_pNext != NULL)
		{
			pNode = pNode->m_pNext;
		}

		pNode->m_pNext = pNew;
	}
}

//2.使用返回值的方式来返回链表的更新
LinkNode* AddToTail1(LinkNode *pHead, int value)
{
	LinkNode *pNew = new LinkNode();
	pNew->m_pData = value;
	pNew->m_pNext = NULL;

	if(pHead == NULL)
	{
		pHead = pNew;
	}
	else
	{
		LinkNode *pNode = pHead;
		while(pNode->m_pNext != NULL)
		{
			pNode = pNode->m_pNext;
		}

		pNode->m_pNext = pNew;
	}

	return pHead;
}
//3.c++的话应该使用引用来避免这些复杂的操作
void AddToTail2(LinkNode* &pHead, int value)
{
	LinkNode *pNew = new LinkNode();
	pNew->m_pData = value;
	pNew->m_pNext = NULL;

	if(pHead == NULL)
	{
		pHead = pNew;
	}
	else
	{
		LinkNode *pNode = pHead;
		while(pNode->m_pNext != NULL)
		{
			pNode = pNode->m_pNext;
		}

		pNode->m_pNext = pNew;
	}
}

//移除一个节点
void RemoveNode(LinkNode **pHead, int value)
{
	if(pHead==NULL || *pHead==NULL)
	{
		return ;
	}

	LinkNode *pDeleteNode = NULL;
	if((*pHead)->m_pData == value)
	{
		pDeleteNode = *pHead;
		*pHead = (*pHead)->m_pNext;
	}
	else
	{
		LinkNode *pNode = *pHead;
		while(pNode->m_pNext != NULL && pNode->m_pNext->m_pData != value)
		{//这里查找有点小技巧，总是查找下一个节点，这样删除就方便多了
			pNode = pNode->m_pNext;
		}

		//如果找到了
		if(pNode->m_pNext != NULL && pNode->m_pNext->m_pData==value)
		{
			pDeleteNode = pNode->m_pNext;
			pNode->m_pNext = pNode->m_pNext->m_pNext;
		}
	}

	if(pDeleteNode != NULL)
	{
		delete pDeleteNode;
		pDeleteNode = NULL;
	}
	
}
int main()
{
	//第一种方式的测试
	LinkNode *pHead = NULL;
	AddToTail(&pHead, 14);
	cout<<pHead->m_pData<<endl;

	//第二种方式的测试
	LinkNode *pHead1 = NULL;
	pHead1 = AddToTail1(pHead1,12);
	cout<<pHead1->m_pData<<endl;

	//第三种方式，使用引用的方式，性能相比来说还要好，复杂程度还低
	LinkNode *pHead2 = NULL;
	AddToTail2(pHead2,10);
	cout<<pHead2->m_pData<<endl;
	return 0;
}

现在回归正题，对于这个题目，我们有两种思想来做

（1）如果允许修改初始的链表的话，我们可以反转链表，然后输出（暂不考虑）

（2）如果不允许对链表做修改，我们只能遍历链表，将值放到栈中，考虑到栈，就应该考虑到递归，或者使用非递归模拟栈的操作

具体实现如下：

#include <iostream>
using namespace std;

struct LinkNode 
{
	int m_pData;
	struct LinkNode *m_pNext;
};

//反向打印链表节点
//如果不能破坏链表结构，就依次遍历，将值放到栈中，然后从栈中输出，用栈就会想到递归可以使用递归操作
//如果可以破坏链表结构，可以把链表的指针反向，这里只介绍前者

//第一种方式，使用递归的思想
void PrintLinkInReversedOrder(LinkNode *pHead)
{
	if(pHead == NULL)
	{
		return ;
	}
	if(pHead->m_pNext != NULL)
	{
		PrintLinkInReversedOrder(pHead->m_pNext);
	}

	cout<<pHead->m_pData<<endl;
}

//第二种方式， 使用非递归的思想
void PrintLinkInReversedOrder1(LinkNode *pHead)
{
	int stack[100]; //使用数组模拟栈操作
	int sLength=0;
	while(pHead != NULL)
	{
		stack[sLength++] = pHead->m_pData;
		pHead = pHead->m_pNext;
	}

	//打印
	for(int i=sLength-1; i>=0; --i)
	{
		cout<<stack[i]<<endl;
	}
}

int main()
{
	LinkNode *pNode1 = new LinkNode();
	LinkNode *pNode2 = new LinkNode();
	pNode1->m_pData = 10;
	pNode1->m_pNext = pNode2;

	pNode2->m_pData = 20;
	pNode2->m_pNext = NULL;

	//1,有两个节点
	LinkNode *pHead1;
	pHead1=pNode1;
	PrintLinkInReversedOrder(pHead1);
	PrintLinkInReversedOrder1(pHead1);
	//2.有一个节点
	LinkNode *pHead2=pNode2;
	PrintLinkInReversedOrder(pHead2);
	PrintLinkInReversedOrder1(pHead2);
	//3.NULL链表
	LinkNode *pHead3 = NULL;
	PrintLinkInReversedOrder(pHead3);
	PrintLinkInReversedOrder1(pHead3);
	return 0;
}