【链表】反转/逆置 链表，以及升级版Node* RotateList(Node* list, size_t k)

最新推荐文章于 2024-04-15 23:01:14 发布
最新推荐文章于 2024-04-15 23:01:14 发布
阅读量404 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 链表 文章标签： 链表 反转链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wenqiang1208/article/details/75103392
本文介绍两种链表反转的方法：一种是基本的链表整体反转；另一种是针对链表中的每k个元素进行局部反转，形成更为复杂的链表结构。通过具体的代码实现，详细解释了这两种方法的具体操作步骤。

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

问题一
问题描述：定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
考虑：1只有一个结点。2、链表为空
//思路：定义三个指针，改变链表结点的指向
//考虑 1一个结点，没有及诶单
Node *ReverseList(Node* pHead)
{
    Node* ReverseHead = NULL;
    Node* pNode = pHead;
    Node* pPrev = NULL;
    while (pNode != NULL)
    {
        Node *pNext = pNode->_next;
        if (pNext == NULL)
            ReverseHead = pNode;
        pNode->_next = pPrev;
        pPrev = pNode;
        pNode = pNext;
    }
    return ReverseHead;
}
问题二：升级版

链表翻转。给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6，用程序实现Node* RotateList(Node* list, size_t k). 提示：这个题是链表逆置的升级变型。

分析问题

思路：链表中长度为k的一段从链表中摘除，翻转之后在将其衔接回链表。
步骤：1、找到k长的链表
2、从原来链表上摘取下来
3、逆置新的链表
4、连接到原来的链表上
循环上面的四个步骤，直到链表的长度不够k。

Node* GetTail(Node *pHead)
{
    assert(pHead);
    Node* pNode = pHead;
    while (pNode->_next != NULL)
    {
        pNode = pNode->_next;
    }
    return pNode;
}
Node* RotateList(Node* pHead, size_t k)
{   
    if (k <= 1)
        return pHead;
    Node *pNewList = NULL;
    Node *pLastNode = NULL;//记录上一段链表的末尾
    Node *pNextNode = NULL;//k链表的下一个节点
    Node *pNewHead = NULL; //新链表的头
    Node *pNode = pHead;
    while (pNode)
    {
        //找出长度为k的一段链表
        pNewHead = pNode;
        size_t pos = 1;
        while (pNode && pos < k)
        {
            pNode = pNode->_next;
            pos++;
        }       
        if (pos == k && pNode != NULL)
        {
            //找到的长度k的一段链表，逆置这段链表
            pNextNode = pNode->_next;
            pNode->_next = NULL;
            //断开新链表与原来的链表
            if (NULL != pLastNode)
                pLastNode->_next = NULL;

            pNewHead = ReverseList(pNewHead);
            //将这段链表连接到原来的链表上 1和2
            //1、将新链表的头 链到原来的链表
            if (pLastNode == NULL)
            {
                pNewList = pNewHead;
            }           
            else
            {
                pLastNode->_next = pNewHead;
            }
            //2、将新链表的尾 连接到原来的链表上
            //找新链表的尾
            pNode = GetTail(pNewHead);
            pNode->_next = pNextNode;
            pLastNode = pNode;
            pNode = pNextNode;//开始下一轮找k长链表
        }
        else
            break;
    }
    return pNewList;
}
单链表的逆置
嗯呢嗯呢的博客
06-06 719
单链表的逆置。例如：输入字符串abcd，输出字符串dcba class Lnode{ char data; Lnode next; } public class Main { //返回带头结点的单链表L的逆转链表 public static Lnode Reverse( Lnode L ) { Lnode Old_head, New_head, Temp; New_head = null; Old_head = L.next; whil
PTA 链表逆序 程序实现了一个单链表的逆序。请完成函数list_reverse()。
Celia_ahhh的博客
05-17 783
程序实现了一个单链表的逆序。请完成函数list_reverse()。 函数接口定义： Node* list_reverse(Node* head) head是单链表的头指针，函数返回逆序后的头指针。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct ListNode { int num; struct ListNode
链表翻转（升级版）【每日一题】
985136449的博客
07-23 298
题目：链表翻转。给出一个链表和一个数k，比如链表 1→2→3→4→5→6，k=2，翻转后2→1→4→3→6→5，若k=3, 翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6， 用程序实现Node* RotateList(Node* list, size_t k)。 解决方法：思路和链表翻转一样是将该节点原来指向下一个节点的指针指向该节点的前一个节点，最后得到的新链表的头节
reverseNode 反转链表
qq_26410101的博客
03-16 439
反转一个单链表。 示例: 输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL 输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 思路一：迭代 保存三个变量pre，head，tmpHead分别对应当前节点head的前一个节点，当前节点，下一个节点，然后： head指向...
升级版链表反转
qq_34068766的博客
09-15 189
#include &lt;iostream&gt; using namespace std; typedef struct ListNode{ int val; struct ListNode *next; ListNode(int x):val(x),next(NULL){}; }ListNode; void printlist(ListNode *p) { ...
链表翻转(给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，翻转后2→1→4→3→6→5)
Begin
07-25 1811
链表翻转。 给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6，提示：这个题是链表逆置的升级变型。 代码： pNode RotateList(pNode* pHead, DataType k) { pNode pPre = Find(*pHead, k); pPre
python链表逆置代码
09-15
这段代码首先创建了一个简单的链表`1->2->3->4->5`，然后通过调用`reverse_linked_list`函数逆置链表，最后输出逆置后的链表`5->4->3->2->1`。 #### 六、总结 通过以上分析，我们可以看到如何使用Python实现链表...
链表基础3——单链表的逆置（c语言实现）
2301_80224556的博客
04-15 6421
递归法的好处是代码简洁，但递归深度较大时可能会导致栈溢出。
#include <stdio.h> #include <stdlib.h> //第一关代码 struct node {//此处填写代码，定义链表结点类型，包含一个存放整型数据的 data 成员，和一个指向下一个结点的next成员 }; struct node *mycreateList() {//此处填写代码，创建一个只有一个头结点的空链表，头节点的数据域赋值为0，并将表头结点的地址返回 } //第二关代码 void myinsertHead(struct node * head, int insData ) { /*在此处完成任务，实现在head为表头d 链表的头插数据元素insData的功能*/ //begin //end } void myinsertTail(struct node * head , int insData ) { /*在此处完成任务，在head为表头的单链表表尾插入数据元素insData*/ //begin //end } void myprintList(struct node *L) { /*在此处完成任务，输出L为表头链表中的数据，每输出一个数据换一行*/ //begin //end } //第三关代码 void reverseList_link( struct node *L) { //请在此处填入代码，实现链表逆置功能 //begin //end } //第四关代码 int locateAndChange( struct node *L, int data) { //请在此处填入代码，在头结点为L的链表中查找 与data值相等的第一个结点，若能找到该结点，则将该结点的值与前驱结点的值交换 //若未找到与data值相等的结点，则返回值为-1，若找到的结点无前驱结点，则返回值为0，否则返回值为前驱结点的值 //begin //end } //第五关代码 int destroyList(struct node *L) { //请在此处填写代码，实现将链表L的结点空间回收 //返回值为回收结点的个数，含头结点在内 }
最新发布
03-24
以下是基于 C 语言实现单链表的基本操作，包括创建、头插法、尾插法、打印链表、逆置链表以及删除链表的功能。 #### 定义链表结构体 ```c #include #include typedef struct LNode { int data; struct LNode* ...
#include <iostream> using namespace std; struct Node { int data; struct Node *next; }; //链表结点结构 void createlist_r(struct Node *&head)//尾插法建单链表，没有头结点，输入顺序就是结点顺序 { int n,i; struct Node *p,*tail; head=new Node; cin>>n; cin>>head->data; head->next=nullptr; tail=head; for(i=0; i<n-1; i++) { p=new Node; cin>>p->data; p->next=nullptr; tail->next=p; tail=p; } } void display(struct Node *head)//输出不带头结点的单链表 { struct Node *p; p=head; while(p!=nullptr) { cout<<p->data<<" "; p=p->next; } cout<<endl; } void deletelist(struct Node *&head) //删除单链表 { struct Node *p; while(head) { p=head; head=head->next; delete(p); } head=nullptr; //一定要赋值为空，否则容易造成野指针访问 } //请在以下空白处编写reverselit函数，完成原地逆转，即过程中不在分配新的结点也不撤销旧的结点 /********** Write your code here! **********/ /*******************************************/ int main() { int t; cin>>t; while(t--) { struct Node *head; createlist_r(head); display(head); reverselist(head); display(head); deletelist(head); } return 0; }【id:425】【34分】B. 链表原地逆转并输出（填空题） 时间限制 4s 内存限制 128MB 题目描述 按数字输入顺序创建单链表。不可借助数组、容器，不可开辟新结点空间。编写函数，在原链表上实现单链表的反转。例如单链表10->20->30，反转后变为单链表30->20->10。补全代码
03-20
逆置的话，就是要让每个节点的next指向前一个节点，这样整个链表的方向就反转了。 根据引用[2]提到的，遍历过程中需要设置辅助指针来记录先前遍历的节点。可能要用到三个指针：当前节点、前一个节点和下一个节点。...
VB.rar_vb 链式结构_链表
09-24
'在此添加代码以逆置链表 End Function ``` 总结来说，VB中实现链式结构的单链表存储多项式，涉及的主要步骤包括定义链表节点类、多项式类，以及实现多项式相加和链表逆置的算法。这要求我们对链表操作有深入的...
单链表的反转
weixin_30260399的博客
09-08 84
1 Node *list_reverse(Node *head) { 2 if(NULL == head) { 3 return NULL; 4 } 5 Node *prev,*curr,*reverse_head,*temp; 6 prev=NULL,curr=head; 7 while(curr->n...
反转单链表
Steve Sun的专栏
03-24 817
struct Node{ int data; struct Node *next; }; Node* ReverseList(Node *head){ Node *pre, *cur, *next; if(head == NULL || head->next == NULL) return head; cur = head->next; pre = head; pre->nex
就地链表反转_单链表就地反转
weixin_39633054的博客
12-21 107
实现一个函数:void reverse(struct list_node *head)在尽量不借助辅助变量的情况下，实现任意长度单链表(不考虑内存限制)的反转(or 逆序)。struct list_node{int val;struct list_node *next;};struct list{struct list_node *head;struct list_node *tail;};voi...
链表翻转
liuchen8888的专栏
10-29 89
#include <stdio.h> #include <stdlib.h> struct ListNode { int num; ListNode *next; }; void reverse(ListNode *head){ ListNode *trverse=head; ListNode *reverse= NULL; if(trverse ==N...
单向链表逆序的3种实现
WINGCREATE的专栏
01-02 817
<br />【遍历实现】<br />Node *reverse(Node *list)<br />{<br />    link t, y = list, r = 0;<br />    while (y != 0) { t = y->next; y->next = r; r = y; y = t; }    <br />    return r;<br />}<br />其实上面的这个操作自然地对应于栈的出栈/压栈操作.<br /><br />【基于栈思想的实现】<br />// 1. 判断栈是否为空<b
已知链表的头结点head,写一个函数把这个链表逆序
u012353408的专栏
10-07 7287
若链表为空或只有一个元素，则直接返回；   2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继；   3). 重复2),直到q为空   4). 调整链表头和链表尾
C 语言编程 — size_t 的意义与作用
烟云的计算
05-15 5938
目录 文章目录目录size_t 的作用size_t 的使用 size_t 的作用 在 C 语言程序中使用 size_t（size_type）可以提高代码的可移植性、有效性、可读性。实际上，在 K&D C 中并没有提供 size_t 类型，而是 C 标准委员会为了解决程序的可移植性问题将 size_t 引入的。 在 C 标准库中，许多函数的参数或返回值都是用字节（Byte）来表示对象的大小。例如： malloc(n)：n 指明了需要申请的内存大小。 memcpy(s1, s2, n)：n 表明了需要
C/C++/linux易忘知识点（偏算法）
XMxiaofeng的博客
10-12 363
1.单链表反转 1.使用三个指针遍历单链表，逐个链接点进行反转。 Node * ReverseList(Node *head) { Node *p1,*p2,*p3; if(head==NULL||*head==NULL) return head; p1=head; p2=p1->next; while(p2) //注意条件 { p3=p2->next; //要改变p2->next的指针，所以必须先保留p2->next
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值