问题描述:输入一个链表,从尾到头打印链表每个节点的值。
函数接口:vector< int > printListFromTailToHead(ListNode* head)
这个题的解法呢有下面几种
1.不根据这个接口写的话就是直接递归从头到尾打印单链表
2.根据接口写的话,首先因为给的接口的返回值是一个vector类型的,所以我们可以推断出应该是将链表中的元素从尾到头放在vector中,然后将vector返回去,所以
①利用递归遍历单链表将元素从尾到头放进vector中
②利用栈的特性,从头到尾遍历单链表,将其元素依次入栈,然后在将栈顶元素弹出,压入vector中
③利用vector的特性,从头到位遍历单链表,然后头插到vector中,这样最后的vector中元素的顺序就是单链表的逆序顺序
下面一次给出每个代码的算法实现,顺序根据上面描述算法的顺序
1.不根据接口写
void printListFromTailToHead1(pListNode _head)
{
if (_head == NULL)
return;
printListFromTailToHead1(_head->next);
cout << _head->_data << " ";
}
根据接口写
2.也是利用递归
vector<int> printListFromTailToHead2(ListNode* head)//逆序输出单链表正常方法
{
if (head != NULL)
{
if (head->next != NULL)
{
s = printListFromTailToHead2(head->next);
}
s.push_back(head->_data);
}
return s;//这里的s是我定义好的vector
}
3.根据栈的特性
vector<int> printListFromTailToHead3(ListNode* head)//方法3
{
stack<int> st;
while (head)
{
st.push(head->_data);
head = head->next;
}
while (!st.empty())
{
s.push_back(st.top());
st.pop();
}
return s;
}
4.利用vector的特性
vector<int> printListFromTailToHead4(ListNode* head)
{
while (head != NULL)
{
s.insert(s.begin(), head->_data);
head = head->next;
}
return s;
}
下面再给出我测试的单链表部分的代码
注意我创建的单链表的顺序是:1 2 3 4 5
typedef struct ListNode//单链表的结点
{
int _data;
ListNode *next;
ListNode(int data)
:_data(data)
, next(NULL){}
ListNode()
:next(NULL){}
}*pListNode;
class Node
{
private:
vector<int> s;
pListNode head;//头指针
public:
Node(int *array, int size)//构造函数创建无头单链表
:head(NULL)
{
for (int i = 0; i < size; i++)
{
if (head == NULL)
{
head = new ListNode(array[i]);
head->next = NULL;
}
else
{
pListNode cur = new ListNode(array[i]);
cur->next = head;
head = cur;
}
}
}
~Node()//析构函数
{
while (head != NULL)
{
pListNode cur = head;
head = head->next;
delete cur;
}
}
};
下面给出完整的代码和测试结果
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
typedef struct ListNode
{
int _data;
ListNode *next;
ListNode(int data)
:_data(data)
, next(NULL){}
ListNode()
:next(NULL){}
}*pListNode;
class Node
{
private:
vector<int> s;
pListNode head;//头指针
public:
Node(int *array, int size)//构造函数创建无头单链表
:head(NULL)
{
for (int i = 0; i < size; i++)
{
if (head == NULL)
{
head = new ListNode(array[i]);
head->next = NULL;
}
else
{
pListNode cur = new ListNode(array[i]);
cur->next = head;
head = cur;
}
}
}
~Node()//析构函数
{
while (head != NULL)
{
pListNode cur = head;
head = head->next;
delete cur;
}
}
void _printListFromTailToHead1()//没有使用接口的递归打印
{
printListFromTailToHead1(head);
}
vector<int> _printListFromTailToHead2()//使用接口的递归打印,这里用进行了封装
{
s = printListFromTailToHead2(head);
return s;
}
vector<int> _printListFromTailToHead3()//使用接口的栈的特性
{
s= printListFromTailToHead3(head);
return s;
}
vector<int> _printListFromTailToHead4()//使用vector的特性
{
s = printListFromTailToHead4(head);
return s;
}
private:
void printListFromTailToHead1(pListNode _head)//没有使用接口的递归打印
{
if (_head == NULL)
return;
printListFromTailToHead1(_head->next);
cout << _head->_data << " ";
}
vector<int> printListFromTailToHead2(ListNode* head)//使用接口递归
{ if (head != NULL)
{
if (head->next != NULL)
{
s = printListFromTailToHead2(head->next);
}
s.push_back(head->_data);
}
return s;//这里的s是我定义好的vector
}
vector<int> printListFromTailToHead3(ListNode* head)//使用接口利用栈的性质
{
stack<int> st;
while (head)
{
st.push(head->_data);
head = head->next;
}
while (!st.empty())
{
s.push_back(st.top());
st.pop();
}
return s;
}
vector<int> printListFromTailToHead4(ListNode* head)//使用接口利用vector的性质
{
while (head != NULL)
{
s.insert(s.begin(), head->_data);
head = head->next;
}
return s;
}
};
int main()
{
int arr[5] = { 5, 4, 3, 2, 1 };
vector<int> test;
Node LT(arr, 5);
LT._printListFromTailToHead1();
test=LT._printListFromTailToHead2();
test = LT._printListFromTailToHead3();
test = LT._printListFromTailToHead4();
system("pause");
return 0;
}
因为没有用接口的函数直接打印出来的而其余的没有打印,所以测试结果如下