链表逆置，递归实现

最新推荐文章于 2022-10-24 21:51:21 发布

原创最新推荐文章于 2022-10-24 21:51:21 发布 · 755 阅读

0 ·

CC 4.0 BY-SA版权

算法练习专栏收录该内容

53 篇文章

订阅专栏

本文介绍了如何使用递归方法来实现链表的逆置操作，通过遍历到链表末尾并从后向前添加元素。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

用递归遍历到最后一个元素，从最后一个元素开始操作。设P逆置链表的尾指针，在尾指针后面不断加入新的元素即可。

#include <iostream>

using namespace std;

struct node{
    int x;
    node *next;
    node(int x = 0, node *next = NULL) : x(x), next(next){}
};


class lst{
public:
    lst(){
        head = NULL;
        size = 0;
    }
    
    ~lst(){
        while (head->next)
        {
            node *p = head->next;
            head->next = p->next;
            delete p;
        }
        delete head;
        size = 0;
    }
    
    void push_back(int value){
        node *p = head;
        if (p == NULL){
            p = new node(value);
            head = p;
        }
        else{
            while (p->next){
                p = p->next;
            }
            p->next = new node(value);
        }
        size++;
    }
    
    void push_front(int value){
        node *p = head;
        if (p == NULL){
            p = new node(value);
            head = p;
        }
        else{
            p = new node(value, head->next);
            p->next = head;
            head = p;
        }
    }
    
    void inverse(node* current, node* &p){
        if (current)
        {
            head = current;
            inverse(current->next, p);
            if (p == NULL) {
                p = current;
                p->next = NULL;
            }
            else {
                p->next = current;
                p = current;
                p->next = NULL;
            }
        }
    }
    
    friend ostream& operator << (ostream &out, lst &x){
        node *p = x.head;
        while (p){
            out << p->x << ' ';
            p = p->next;
        }
        return out;
    }
    
    node* begin(){
        return head;
    }
    
private:
    node *head;
    int size;
};

int main(){
    lst l;
    node *p = NULL;
    for (int i = 0; i < 10; i++){
        l.push_front(i);
    }
    cout << l << endl;
    l.inverse(l.begin(), p);
    cout << l << endl;
    
    return 0;
}