c语言，链表的反转，请写出代码，并讲解下，谢了！！！！！

Posted 2023-04-08

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c语言，链表的反转，请写出代码，并讲解下，谢了！！！！！相关的知识，希望对你有一定的参考价值。

扣着的是头节点（头子）

车是首节点（首子）

马是次节点（次子）

牙签细的是指针指向，香头发黑的是指向，铁头细的是指向。

根据步骤写程序的伪算法（3步4循环，7张图片搞定），如下：

以下是while循环（条件：香头指向不为空）

第一个循环把马弄到车前面，

第二个循环把相弄到马前面

第三个循环把士弄到相前面

........

直到香指向为空后停止循环。

代码如下：只需要一个首结点pHead,就能把链表找到，并倒置。具体代码如下

p香=pHead->pNext;

p铁=p香->pNext;

p香->pNext=NULL;

P香=p铁

while(p香！=NULL)

p铁=p香->pNext;

p香->pNext=pHead->pNext;

pHead->pNext=p香；

p香=p铁；

对照伪算法（三步四循环），和上面的代码是一一对应的：

第一步：香头指向首子，铁头指向次子

第二步：删掉首子指向次子（铁头所指向的那个子）的牙签

第三步：香头跟着铁头

以下循环条件：（条件：香头指向不为空）

循环1：铁头移动到香头的下一个指向

循环2：香头的下一个指向首子

循环3：头子的下一个跟着香头

循环4：香头跟着铁头

自己用道具操作几遍，然后把流程背会，以后自己根据流程写代码即可。

参考技术A 基本思路：不需要增加新的结点，只需修改原结点的指针。首先将原链表分为一个空链表h和一个无头结点的链表p，然后通过将链表p的elem依次摘下来插入到空链表的头指针h之后。
void reverseLinklist（linklist h）

linklist p，q；
p = h->next;
h->next = NULL;

while (NULL != P)

q = p;
p = p->next;
q ->next = h->next;
h->next = q;

return ;
参考技术B 单链表反转很简单，只说下思路：
1，从头到尾循环遍历链表
2，取下头结点，作为尾结点，尾结点此时也为头结点
3，采用前插法，将步骤二中取下的结点一个一个连接到头结点前面，成为新的头结点。
4，链表全部遍历完后，新的链表产生了，是原来链表的反转。参考技术C /*
0 2 4 6 8
8 6 4 2 0
Press any key to continue
*/
#include <stdio.h>
#include <stdlib.h>

#define ELTYPE int

typedef struct node
ELTYPE m;
struct node *next;
*NODE;

void InversionNode(NODE head)
NODE p,t,q;
p = NULL;
t = head->next;
q = t->next;
if(t == NULL || q == NULL) return; // 空表和仅有一个结点的链表不用倒置
while(q)
t->next = p; // 倒置结点
p = t; // p指向新倒置的结点
t = q; // 前进一个结点
q = q->next;

t->next = p; // 处理最后一个结点
head->next = t; // head指向倒置后的链表

void ShowNode(NODE head)
NODE p = head->next;
for(;p;p = p->next) printf("%d ",p->m);
printf("\n");

NODE CreatNode(int n) // 创建有头结点的单向链表
int i;
NODE head,p,q;
head = p = (NODE)malloc(sizeof(node));
for(i = 0; i < n; ++i)
q = (NODE)malloc(sizeof(node));
q->m = 2 * i;
p->next = q;
p = q;

p->next = NULL;
return head;

int main()
NODE head = CreatNode(5);
ShowNode(head);
InversionNode(head);
ShowNode(head);
return 0;
本回答被提问者采纳参考技术D 我来做任务的，不过链表来讲，还是自己做的好。能做一个完整的链表，对水平有很大提高

剑指 Offer 24. 反转链表 c++/java详细题解

1、题目

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <=5000

2、思路

(双指针，迭代) $(n)$

给定一个链表的头节点，让我们反转该链表并输出反转后链表的头节点。

样例：

如样例所示，原始链表为1->2->3->4->5->NULL，我们将其翻转输出5->4->3->2->1->NULL。下面我们来讲解双指针的做法。

将一个链表翻转，即将该链表所有节点的next指针指向它的前驱节点。由于是单链表，我们在遍历时并不能直接找到其前驱节点，因此我们需要定义一个指针保存其前驱节点。

每次翻转时，我们都需要修改当前节点的next指针，如果不在改变当前节点的next指针前保存其后继节点，那么我们就失去了当前节点和后序节点的联系，因此还需要额外定义一个指针用于保存当前节点的后继节点。

具体过程如下：

1、定义一个前驱指针pre和cur指针，pre指针用来指向前驱节点，cur指针用来遍历整个链表，初始化pre = null，cur = head。

2、我们首先保存cur指针指向节点的后继节点，然后让cur指针指向节点的next指针指向其前驱节点，即cur->next = pre。

3、pre指针和cur指针分别后移一位，重复上述过程，直到cur指向空节点。

4、最后我们返回pre节点。

图示过程如下：

时间复杂度分析： 只遍历一次链表，时间复杂度是 $O (n)$ 。

3、c++代码

class Solution 
public:
    ListNode* reverseList(ListNode* head) 
        ListNode *pre = NULL;
        ListNode *cur = head;
        while(cur)
        
            ListNode *t = cur->next; //保留cur的后继节点
            cur->next = pre;         //cur指向其前驱节点
            pre = cur, cur = t;
        
        return pre;                  //最后返回pre
    
;

4、java代码

class Solution 
    public ListNode reverseList(ListNode head) 
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null)
        
            ListNode t = cur.next;  //保留cur的后继节点
            cur.next = pre;         //cur指向其前驱节点
            pre = cur;
            cur = t;
        
        return pre;					//最后返回pre