数据结构 C++反转链表

反转链表

定义节点类型

// 定义节点类型
class Node
{
public:
    Node(int data) : _data(data), next(nullptr) {}

public:
    int _data;
    Node *next;
};

定义链表

// 定义链表
class LinkList
{
public:
    LinkList() : head(nullptr), size(0) {}
    ~LinkList()
    {
        Node *current = head;
        while (current != nullptr)
        {
            Node *next = current->next;
            std::cout << "del is " << current->_data << std::endl;
            delete current;
            current = next;
        }
    }
    void insertAtHead(int data); // 头插法
    void printfList();           // 打印
    void reverseIterative();     // 迭代法反转链表
    void reverseRecursive();     // 递归
    void reverseInsertHead();    // 头插
    void reverseUsingStack();    // 栈
    Node *reverseRecursiveHepler(Node *node);

public:
    Node *head;
    int size;
};

1.迭代反转

// 定义链表
class LinkList
{
public:
    LinkList() : head(nullptr), size(0) {}
    ~LinkList()
    {
        Node *current = head;
        while (current != nullptr)
        {
            Node *next = current->next;
            std::cout << "del is " << current->_data << std::endl;
            delete current;
            current = next;
        }
    }
    void insertAtHead(int data); // 头插法
    void printfList();           // 打印
    void reverseIterative();     // 迭代法反转链表
    void reverseRecursive();     // 递归
    void reverseInsertHead();    // 头插
    void reverseUsingStack();    // 栈
    Node *reverseRecursiveHepler(Node *node);

public:
    Node *head;
    int size;
};

2.递归

// 递归
void LinkList::reverseRecursive()
{
    head = reverseRecursiveHepler(head);
}

Node *LinkList::reverseRecursiveHepler(Node *node)
{
    if (node == nullptr || node->next == nullptr)
    {
        return node;
    }
    Node *newNode = reverseRecursiveHepler(node->next);
    node->next->next = node;
    node->next = nullptr;
    return newNode;
}

3.头插法反转链表

void LinkList::reverseInsertHead()
{
    Node *newHead = nullptr;
    Node *current = head;
    while (current != nullptr)
    {
        Node *temp = current;
        current = current->next;
        temp->next = newHead;
        newHead = temp;
    }
    head = newHead;
}

4.栈

void LinkList::reverseUsingStack()
{
    if (head == nullptr || head->next == nullptr)
    {
        return;
    }

    std::stack<Node *> nodeStack;
    Node *current = head;

    // 压栈时断开节点连接
    while (current != nullptr)
    {
        Node *next = current->next;
        current->next = nullptr; // 断开当前节点的连接
        nodeStack.push(current);
        current = next;
    }

    // 创建哑节点简化操作
    Node dummy(0);
    current = &dummy;

    while (!nodeStack.empty())
    {
        current->next = nodeStack.top();
        nodeStack.pop();
        current = current->next;
    }

    head = dummy.next; // 更新头指针
}

完整代码

#include <iostream>
#include <stack>
// 定义节点类型
class Node
{
public:
    Node(int data) : _data(data), next(nullptr) {}

public:
    int _data;
    Node *next;
};

// 定义链表
class LinkList
{
public:
    LinkList() : head(nullptr), size(0) {}
    ~LinkList()
    {
        Node *current = head;
        while (current != nullptr)
        {
            Node *next = current->next;
            std::cout << "del is " << current->_data << std::endl;
            delete current;
            current = next;
        }
    }
    void insertAtHead(int data); // 头插法
    void printfList();           // 打印
    void reverseIterative();     // 迭代法反转链表
    void reverseRecursive();     // 递归
    void reverseInsertHead();    // 头插
    void reverseUsingStack();    // 栈
    Node *reverseRecursiveHepler(Node *node);

public:
    Node *head;
    int size;
};

// 头插法
void LinkList::insertAtHead(int data)
{
    Node *newNode = new Node(data);
    newNode->next = head;
    head = newNode;
    size++;
}

// 打印
void LinkList::printfList()
{
    Node *current = head;
    std::cout << "Head->";
    while (current != nullptr)
    {
        std::cout << current->_data;
        if (current->next != nullptr)
        {
            std::cout << " -> ";
        }
        current = current->next;
    }
    std::cout << " -> nullptr" << std::endl;
}

// 迭代法反转链表
void LinkList::reverseIterative()
{
    Node *prev = nullptr;
    Node *cur = head;
    Node *next = nullptr;
    while (cur != nullptr)
    {
        next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    head = prev;
}

// 递归
void LinkList::reverseRecursive()
{
    head = reverseRecursiveHepler(head);
}

Node *LinkList::reverseRecursiveHepler(Node *node)
{
    if (node == nullptr || node->next == nullptr)
    {
        return node;
    }
    Node *newNode = reverseRecursiveHepler(node->next);
    node->next->next = node;
    node->next = nullptr;
    return newNode;
}

// 头插法反转链表
void LinkList::reverseInsertHead()
{
    Node *newHead = nullptr;
    Node *current = head;
    while (current != nullptr)
    {
        Node *temp = current;
        current = current->next;
        temp->next = newHead;
        newHead = temp;
    }
    head = newHead;
}

// 栈
void LinkList::reverseUsingStack()
{
    if (head == nullptr || head->next == nullptr)
    {
        return;
    }

    std::stack<Node *> nodeStack;
    Node *current = head;

    // 压栈时断开节点连接
    while (current != nullptr)
    {
        Node *next = current->next;
        current->next = nullptr; // 断开当前节点的连接
        nodeStack.push(current);
        current = next;
    }

    // 创建哑节点简化操作
    Node dummy(0);
    current = &dummy;

    while (!nodeStack.empty())
    {
        current->next = nodeStack.top();
        nodeStack.pop();
        current = current->next;
    }

    head = dummy.next; // 更新头指针
}

int main()
{
    LinkList *list = new LinkList();

    for (int i = 1; i <= 5; ++i)
    {
        list->insertAtHead(i);
    }

    std::cout << "Original list: ";
    list->printfList();

    // 测试各种反转方法
    std::cout << "\nTesting reverseIterative:\n";
    list->reverseIterative();
    list->printfList();

    std::cout << "\nTesting reverseRecursive:\n";
    list->reverseRecursive();
    list->printfList();

    std::cout << "\nTesting reverseInsertHead:\n";
    list->reverseInsertHead();
    list->printfList();

    std::cout << "\nTesting reverseUsingStack:\n";
    list->reverseUsingStack();
    list->printfList();

    delete list;
    return 0;
}