从尾到头打印单链表

问题描述：输入一个链表，从尾到头打印链表每个节点的值。

函数接口：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;
}

因为没有用接口的函数直接打印出来的而其余的没有打印，所以测试结果如下