数据结构——单链表逆序的四种思路（数组，栈，逆序链表，递归）（C++实现）

实现代码：

/*************************************************************************
	> File Name: invertLinkList.cpp
	> Author: 念念
	> Mail: 2845906049@qq.com 
	> Created Time: 2021年08月20日 星期五 16时52分40秒
    > Function: 链表逆序的四种思路（数组，栈，逆序链表，递归）
 ************************************************************************/
#include <iostream>
#include <vector>
#include <stack>
#include <stdlib.h>
#include <time.h>

using namespace std;

struct Node
{
    int data;
    Node *next;
};

//写一个链表类，实现四种链表逆序打印方式（数组，栈，逆序链表，递归）
class LinkList
{
public:
    LinkList(){head = new(Node);head->next = NULL;}
    void setRandList(int len); //生成len个随机数并插入链表
    void insert(int i,int index = 1); //插入,可指定位置，默认头插
    void print() const; //打印
    void invertPrint_vector() const;//使用数组，不改变链表本身
    void invertPrint_stack() const;//使用栈，不改变链表本身
    void invertprint_linklist();//直接逆序链表
    void invertprint_recursion() const;//递归打印，不改变链表本身
    void invertprint_recursion(Node * node) const; //递归时需传参调用该函数

private:
    Node * head;
    int length = 0;
};

void LinkList::setRandList(int len)
{
    srand((unsigned)time(NULL));
    for(int i = 0;i < len; i++)
    {
        insert(rand()%99+1);
    }
}

void LinkList::insert(int data,int index)
{
    if(index > length + 1)
    {
        throw "位置出错！";
    }
    else
    {
        Node *p = head;
        for(int i = 1; i < index; i++)
        {
            p = p->next;
        }
        Node *newnode = new Node;
        newnode->data = data;
        newnode->next = p->next;
        p->next = newnode;
        length++; 
    }
}

void LinkList::print() const
{
    if(NULL == head->next){return;}
    cout << "\n当前正序输出：";
    Node *p = head->next;
    while(NULL != p)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

void LinkList::invertPrint_vector() const
{
    if(NULL == head->next){return;}
    cout << "数组倒序：";
    vector<int> v;
    Node *p = head->next;
    while(NULL != p)
    {
        v.emplace_back(p->data);
        p = p->next;
    }
    for(auto it = v.end() - 1; it >= v.begin(); it--)
    {
        cout << *it << " ";
    }
    cout << endl;
}

void LinkList::invertPrint_stack() const
{
    if(NULL == head->next){return;}
    cout << "栈 倒 序：";
    stack<int> s;
    Node *p = head->next;
    while(NULL != p)
    {
        s.push(p->data);
        p = p->next;
    }
    while(!s.empty())
    {
        cout << s.top() << " ";
        s.pop();
    }
    cout << endl;
}

void LinkList::invertprint_linklist()
{
    if(NULL == head->next){return;}
    cout << "逆序链表(此处使用方法执行过程不打印）：\n";
    Node *p = new(Node);
    p->next = head->next;
    Node *q = new(Node);
    q->next = p->next->next;
    head->next->next = NULL;//必须置空，否则尾节点自循环打印会出错
    head->next = q->next->next;   
    for(int i = 1; i < length - 2; i++)
    {
        q->next->next = p->next;
        p->next = q->next;
        q->next = head->next;
        head->next = head->next->next;
    }
    q->next->next = p->next;
    head->next->next = q->next;
    delete p;
    delete q;
}

void LinkList::invertprint_recursion() const
{  
    if(NULL == head->next){return;}
    cout << "递归倒序：";
    invertprint_recursion(head); 
    //本笨蛋目前没想到更好的用一个函数解决该递归的方法，默认参数为head会报错。
    //如有大佬，请教我！
    cout << endl;
}

void LinkList::invertprint_recursion(Node * node) const
{
    if(NULL == node->next)
    {
        return;
    }    
    invertprint_recursion(node->next);
    cout << node->next->data << " ";  
    //在这里要说明的是，如果把打印放在递归调用前，可以实现正序打印链表
}

int main()
{
    LinkList ll;
    ll.setRandList(10);
    ll.print();
    ll.invertPrint_vector();

    ll.print();
    ll.invertPrint_stack();
    
    ll.print();
    ll.invertprint_linklist1();
    
    ll.print();
    ll.invertprint_recursion();

    ll.print();
    ll.invertprint_recursion();

    ll.print();

    return 0;
}

运行结果：

当前正序输出：94 91 78 54 26 90 75 79 21 80 
数组倒序：80 21 79 75 90 26 54 78 91 94 

当前正序输出：94 91 78 54 26 90 75 79 21 80 
栈 倒 序：80 21 79 75 90 26 54 78 91 94 

当前正序输出：94 91 78 54 26 90 75 79 21 80 
逆序链表(此处使用方法执行过程不打印）：

当前正序输出：80 21 79 75 90 26 54 78 91 94 
递归倒序：94 91 78 54 26 90 75 79 21 80 

当前正序输出：80 21 79 75 90 26 54 78 91 94 
递归倒序：94 91 78 54 26 90 75 79 21 80 

当前正序输出：80 21 79 75 90 26 54 78 91 94