单向链表的递归反转

单向链表反转的递归实现

#include <iostream>

// 链表的节点类型 
struct LinkNode 
{
    int Val;    
    LinkNode * Next;
    LinkNode() { Next = NULL; }
    LinkNode(int v) { Val = v; Next = NULL; } 
};

// 链表类型 
struct List
{
    LinkNode * Head;
    LinkNode * Tail;

    List() 
    {
        Head = new LinkNode;    // dummy node
        Tail = Head;
        Tail->Next = NULL;
        Tail->Val = -1;
    }

    ~List()
    {
        LinkNode * temp;
        while (!empty()) {
            temp = deleteFirstNode();
            delete temp;
        }   
    }

    LinkNode * deleteFirstNode() 
    {
        LinkNode * temp = Head;
        Head = Head->Next;
        return temp;
    }

    void addTailNode(LinkNode * n)
    {
        if (empty()) {
            Head = n;
            n->Next = Tail; 
        } else {
            // 遍历链表，定位到最后一个节点（非哑节点） 
            // 若双向链表，不需遍历 
            LinkNode * t = Head;
            for (; t->Next != Tail; t = t->Next) ;
            t->Next = n;
            n->Next = Tail;
        }
    }

    void print()
    {
        for (LinkNode * t = Head; t != Tail; t = t->Next) {
            std::cout << t->Val << " ";
        }
        std::cout << std::endl;
    }

    bool empty()
    {
        return Head == Tail;
    }
};

// 使用递归的方式反转单向链表
// ---------------------
// 先删掉链表的第一个节点, 然后反转链表
// 最后把删除的第一个节点 链接 到反转后的链表后面 
void reverseList(List & l)
{
    if (l.empty()) return ;
    LinkNode * first = l.deleteFirstNode();
    reverseList(l);
    l.addTailNode(first);
}

int main()
{
    List l;
    // 添加100个元素测试 
    for (int i = 1; i <= 100; ++i) {
        l.addTailNode(new LinkNode(i));
    } 
    l.print();
    reverseList(l);
    l.print();
    return 0;
}

还可以直接使用堆栈实现，效率更高。其实递归也是隐式使用堆栈。