面试题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;
}