单向链表的逆向遍历与反转

单向链接逆向遍历

单向链表顺序遍历很方便，那么逆向遍历呢
首先定义一个链表，然后将其反向输出。
结构体定义如下：

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
    val(x), next(NULL) {
    }
};

将链表反向输出，其过程分解就是先入后出，于是我们想到了一种类似的结构，栈

方法，使用栈。

头文件 ：

#include <stack>
#include <iostream>

栈的规则刚好是先入后出，我们可以利用这个规则将链表依次压入栈中，然后将栈中数据弹出，来达到反向输出链表的目的。

void ListStack(ListNode* pHead)
{
    stack<ListNode*> nodes;
    ListNode* pNode = pHead;
    // 使用stack存储实现先进后出
    while (pNode != nullptr)
    {
        nodes.push(pNode);
        pNode = pNode->next;
    }
    while (!nodes.empty())
    {
        pNode = nodes.top();
        cout << pNode->val<<" ";
        nodes.pop();
    }
}

然后我们在写一个函数来创建一个链表进行测试：

ListNode* CreatList(){
    ListNode* pNode = new ListNode(0);
    pNode->next = NULL;
    ListNode* pHead = pNode;

    for (int i = 1; i < 5; i++) {
        ListNode* pTemp = new ListNode(i);
        pNode->next = pTemp;
        pNode = pTemp;
    }
    return pHead;
}

其结果如下：

实现了反向输出链表

完整代码如下：

#include <iostream>
#include <stack>
using namespace std;
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
    val(x), next(NULL) {
    }

};
void printList(ListNode* pHead){
    ListNode* pTraverse = pHead;
    if (!pTraverse) {
        return;
    }
    while (pTraverse) {
        cout<< pTraverse->val << " ";
        pTraverse = pTraverse->next;
    }
    cout<< endl;
}
ListNode* CreatList(){
    ListNode* pNode = new ListNode(0);
    pNode->next = NULL;
    ListNode* pHead = pNode;

    for (int i = 1; i < 5; i++) {
        ListNode* pTemp = new ListNode(i);
        pNode->next = pTemp;
        pNode = pTemp;
    }
    return pHead;
}
void ListStack(ListNode* pHead)
{
    stack<ListNode*> nodes;
    ListNode* pNode = pHead;
    // 使用stack存储实现先进后出
    while (pNode != nullptr)
    {
        nodes.push(pNode);
        pNode = pNode->next;
    }
    while (!nodes.empty())
    {
        pNode = nodes.top();
        cout << pNode->val<<" ";
        nodes.pop();
    }
}
int main(){
    ListNode* p = CreatList();
    printList(p);
    ListStack(p);
}

另一种方法：使用函数递归

递归调用函数输出最后的内容，在依次返回输出自己本身节点内容。

void ListRecursive(ListNode* pHead)
{
    if (pHead != nullptr)
    {
        if (pHead->next != nullptr)
        {
            PrintListReversinglyRecursively(pHead->next);
        }
        cout << pHead->val << endl;
    }
}

将单链表反转

以无头节点的链表为例
例如:原始链表

新链表：

不是指的替换，而是节点的替换。
递归法
链表的尾节点开始，依次向前遍历，遍历过程依次改变各节点的指向，即另其指向前一个节点。

ListNode* recursive_reverse(ListNode* head) {
    //递归的出口
    if (head == NULL || head->next == NULL)     // 空链或只有一个结点，直接返回头指针
    {
        return head;
    }

    else
    {
        //一直递归，找到链表中最后一个节点
        ListNode* new_head = recursive_reverse(head->next);

        //当逐层退出时，new_head 的指向都不变，一直指向原链表中最后一个节点；
        //递归每退出一层，函数中 head 指针的指向都会发生改变，都指向上一个节点。

        //每退出一层，都需要改变 head->next 节点指针域的指向，同时令 head 所指节点的指针域为 NULL。
        head->next->next = head;
        head->next = NULL;
        //每一层递归结束，都要将新的头指针返回给上一层。由此，即可保证整个递归过程中，能够一直找得到新链表的表头。
        return new_head;
    }
}

迭代反转：
从当前链表的首元节点开始，一直遍历至链表的最后一个节点，这期间会逐个改变所遍历到的节点的指针域，另其指向前一个节点

//迭代反转法，head 为无头节点链表的头指针
link * iteration_reverse(link* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    else {
        link * beg = NULL;
        link * mid = head;
        link * end = head->next;
        //一直遍历
        while (1)
        {
            //修改 mid 所指节点的指向
            mid->next = beg;
            //此时判断 end 是否为 NULL，如果成立则退出循环
            if (end == NULL) {
                break;
            }
            //整体向后移动 3 个指针
            beg = mid;
            mid = end;
            end = end->next;
        }
        //最后修改 head 头指针的指向
        head = mid;
        return head;
    }
}

头插法反转：
是指在原有链表的基础上，依次将位于链表头部的节点摘下，然后采用从头部插入的方式生成一个新链表，则此链表即为原链表的反转版。

link * head_reverse(link * head) {
    link * new_head = NULL;
    link * temp = NULL;
    if (head == NULL || head->next == NULL) {
        return head;
    }
    while (head != NULL)
    {
        temp = head;
        //将 temp 从 head 中摘除
        head = head->next;

        //将 temp 插入到 new_head 的头部
        temp->next = new_head;
        new_head = temp;
    }
    return new_head;
}

就地逆置法
直接对原链表做修改，从而实现将原链表反转，需要额外借助 2 个指针（假设分别为 beg 和 end）。

link * local_reverse(link * head) {
    link * beg = NULL;
    link * end = NULL;
    if (head == NULL || head->next == NULL) {
        return head;
    }
    beg = head;
    end = head->next;
    while (end != NULL) {
        //将 end 从链表中摘除
        beg->next = end->next;
        //将 end 移动至链表头
        end->next = head;
        head = end;
        //调整 end 的指向，另其指向 beg 后的一个节点，为反转下一个节点做准备
        end = beg->next;
    }
    return head;
}