单链表的逆置和从尾到头打印单链表

最新推荐文章于 2020-04-18 15:08:11 发布
最新推荐文章于 2020-04-18 15:08:11 发布
阅读量767 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构之C语言 文章标签： 面试 C数据 从尾到头打印单链 单链表逆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Yinghuhu333333/article/details/79250069
本文介绍了如何使用递归法从尾到头打印单链表，并探讨了两种不同的单链表逆置方法：头插法和初始化三个节点交换赋值法。通过具体的代码实现，详细阐述了这两种操作的步骤和逻辑。

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

从尾到头打印单链表：递归法。先声明一个节点为头结点（cur = *head），当cur->next为空时，输出打印cur节点。否则，就一直调用该节点。

单链表逆置：头插法。即删掉头结点的下一个节点，然后把删掉的节点进行该链表的头插。例如：

这样，就可以把节点b插到a的前面。以此类推，知道cur->next==NULL为止。

单链表逆置还有一种方法：初始化3个节点，然后按照顺序以此进行交换赋值。

实现的代码如下：（在3个文件中编写的）

LinkListTest.h文件

#pragma once

#define TextHeader printf("\n********************%s**********************\n",__FUNCTION__)

typedef char ElemType;
typedef struct LinkListT
{
	ElemType data;
	struct LinkListT* next;
}LinkListT;


LinkListT* head;

//初始化单链表
void LinkListT_Init(Link
最低0.47元/天 解锁文章

200万优质内容无限畅学
数据结构4.4从尾到头打印单链表
weixin_43899452的博客
07-13 352
分析： **方式1：**单链表反转后再遍历（破坏了单链表的结构） **方式2：**利用栈的数据结构，将各个节点压入栈中，然后利用栈的先进后出的结构实现逆序打印。 使用方式2的方法： 测试：
单链表逆置：空间复杂度O(1)
hellogoxiaowu的博客
12-02 893
带头结点单链表逆置 从链表(带头结点)首个数据结点开始，重新头插法建表，将节点链接到头结点上 //单链表结点结构 typedef struct LNode { int data; struct LNode* next; }LNode; void Inversion(LNode* head) { LNode* phead=head->next; LNode* q; head->next=NULL; //头结点next指针置空 while(phead!=NULL) { q=ph
【C语言】单链表的相关热点面试题（包括：从尾到头打印，逆置，冒泡，寻找中间节点，倒数k节点）...
weixin_34101229的博客
05-11 118
从尾到头打印单链表voidFromTailToHeadPrint(SListNode*&head) { stack<SListNode*>s; SListNode*cur=head; while(cur) { s.push(cur); cur=cur->_next; ...
链表笔试题1：从尾到头打印单链表
qq_40421712的博客
08-31 317
从尾到头打印单链表 方法1：遍历重新打印 typedef char ListType; typedef struct ListNode { ListType data; struct ListNode* next; }ListNode; void Printendtofirst(ListNode * first) { ListN...
链表逆置和从尾到头打印单链表
Keep Fighting All The Time
05-16 1949
&amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; 链表的逆置和链表从尾到头打印是两个不同的概念，链表的逆置就是将链表（a1,a2,a3…an）转化为（an，a（n-1),..a1），链表结构会发生改变；而从尾到头打印链表是将链表中的元素逆序打印，即从尾结点开始依次打印，链表的结构不发生改变。 &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp
从尾到头打印单链表
CodingStart
05-28 673
递归实现 从尾到头打印单链表
小白算法积累——单链表3#带头结点单链表+逆置输出
aprilzj123的博客
02-17 2527
题目：设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值。 关键字：带头结点单链表，逆向输出 思路 关注：递归算法的设计重点在于找到“递归”的部分，即重复调用函数，改变部分相关变量 设f(L,x)的功能是：删除以L为首结点指针的单链表中所有值等于x的结点，显然有f(L->next,x) 1.通用逆置函数:遍历循环+头尾元素互换 需要变量：L, 相对头尾结点下标：from, to...
链表经典面试题之从尾到头打印单链表
superwangxinrui的博客
04-02 482
题目：  要求将一无头单链表的节点从尾到头打印出来。这是一道经典的面试题，今天我们来介绍它的五种解决方法。1 解决思路：    定义两个指针，一个指向链表头（pcur)，一个指向每次要打印的节点(pprint)。每次让pcur来遍历，代码实现如下：//从尾到头打印单链表 void THprint2(PNode pHead){ if (NULL == pHead){ return; } P...
6-1 带头结点的单链表就地逆置
Abyss_sliver的博客
09-22 5754
本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。 函数接口定义：void ListReverse_L(LinkList &L);其中 L 是一个带头结点的单链表。 裁判测试程序样例：//库函
从尾到头打印一个链表
weixin_30685047的博客
05-02 148
这样的链表问题时不时的出现，你有没有特定的方法去处理呢：以下给出你可能用到的算法： 第一种：改变链表的结构 思想： 1.从尾到头打印链表，那就逆置链表呗 2.打印逆置后的链表； 这个简单，直接上代码： void PrintListRevers(ListNode* pHead) { //1.链表逆置 ListNode* newHead = NULL; ListNode*...
从尾到头打印一个单链表
destination00的博客
06-11 451
输入一个单链表的头结点，从尾到头打印整个链表每个节点的值 两种思路： 1.不破坏单链表的结构，用栈或者递归的方式实现反转打印； 2.反转整个链表，再打印每个节点的值。 (1)利用栈的数据结构来实现 void PrintList_reverse(ListNode* head) { std::stack<ListNode*> nodes; ListNode* p=head; whil...
【剑指offer】从尾到头打印链表（单链表逆置 + 图解 + 单链表实现）
qq_43676757的博客
04-18 1314
【剑指offer】从尾到头打印链表（单链表逆置） 【本题链接】 【题目描述】 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 【题意解析】 本题就是单链表逆置问题，考察了对于链表结构的掌握 【解题思路】 本题一共有两种解法，一种不改变单链表的结构，另一种改变单链表的结构。 【解法一：】 最简单的获取链表中各个节点的值，然后在数组中进行逆置操作，则可以从尾到头打印单链表，使用到C...
链表--从尾到头打印单链表
sayhello_world的博客
07-18 313
方法一：栈 因为栈是先进后出，所以先将链表全部压入栈，在将栈pop()并输出即可。void PrintLast(ListNode* pHead) { std::stack<ListNode*> s; ListNode* pCur = pHead; while(pCur) { s.push(pCur); pC
实现带表头结点单链表的逆置和排序运算
最新发布
06-05
<think>根据用户查询，需要实现带头结点的单链表的逆置和排序两种操作。参考引用[1]提到直接插入排序，引用[2]和引用[3]分别提供了逆置和排序的代码示例。注意：引用[1]中的插入排序是针对带头结点的单链表，引用[2]的逆置代码也是带头结点的，引用[3]的排序是冒泡排序，也是带头结点的。根据引用[2]：逆置的方法是通过三个指针，将链表节点逐个逆转。根据引用[1]和引用[3]：排序有两种方法，直接插入排序和冒泡排序。考虑到单链表的特点，逆置和排序操作都需要注意不能断链，并且要正确更新头结点的指针。实现方法：1.逆置：引用[2]的代码：StatusReverse(LinkListL){LinkListp=L->next;LinkListq=L->next->next;LinkListt=NULL;while(q!=NULL){t=q->next;q->next=p;p=q;q=t;}L->next->next=NULL;//设置新的尾节点（原第一个节点）的next为NULLL->next=p;//头结点指向新的第一个节点return1;}但是要注意边界条件：如果链表为空或者只有一个节点，则无需逆置。上述代码在链表只有一个节点时，会出现问题（L->next->next访问空指针的next）。所以需要修改。改进的逆置方法（头插法）：将链表从头至尾遍历，将每个节点用头插法插入到链表的头部。步骤如下：p=L->next;//第一个节点L->next=NULL;//将头结点next置空while(p){q=p->next;//保存下一个节点p->next=L->next;//将当前节点插入头结点之后L->next=p;p=q;}头插法更简单，并且容易理解，且可以处理空表和只有一个节点的情况。2.排序：用户引用提供了两种排序方法：直接插入排序（引用[1]）和冒泡排序（引用[3]）。直接插入排序（带头结点）：将链表分为两部分：已排序和未排序。初始时，已排序部分只有第一个节点（认为只有一个节点是有序的），然后依次将后面的节点插入到已排序部分的适当位置。具体步骤：1.断开：将链表拆分成两个链表，初始时，有序链表为头结点+第一个节点，无序链表为剩下的部分。2.逐个取出无序链表的第一个节点，在有序链表中找到合适的位置插入。代码实现思路：if(head->next==NULL||head->next->next==NULL)return;//空表或只有一个节点不需要排序//初始化：有序链表为第一个节点，无序链表为第二个节点开始node*sorted=head->next;//有序链表的最后一个节点（初始为第一个节点）node*curr=sorted->next;//从第二个节点开始sorted->next=NULL;//断开，有序链表独立while(curr){node*next=curr->next;//保存下一个节点，防止断链//在有序链表中找到插入位置（从head开始遍历）node*prev=head;//指向head，因为插入位置可能在第一个节点前node*p=head->next;//有序链表的第一个节点while(p&&p->data< curr->data){prev=p;p=p->next;}//此时prev指向要插入位置的前一个节点，p指向要插入位置的后一个节点（可能为NULL）prev->next=curr;curr->next=p;//更新curr到下一个节点curr=next;}冒泡排序（带头结点）：引用[3]的代码：voidsort(node*head){node*p=head->next;intlen=length(head);inttemp;if(p==NULL||p->next==NULL)return;for(inti=1;i<len;i++){p=head->next;//每次从头开始for(intj=0;j<len-i;j++){if(p->data>p->next->data){//交换节点的值temp=p->data;p->data=p->next->data;p->next->data=temp;}p=p->next;}}}注意：冒泡排序通过双重循环，比较相邻节点并交换节点的值，而不是改变节点之间的链接关系。两种排序方法的比较：插入排序需要修改节点之间的链接关系（重新插入），冒泡排序只需交换节点的值（适合数据域类型简单的节点）。根据用户要求，需要实现带头结点的单链表的逆置和排序运算。因此，我们可以提供：逆置：使用头插法（改进的，安全的方法）。排序：提供两种方法（插入排序和冒泡排序），但插入排序更常用，因为冒泡排序需要频繁交换值，而链表节点数据交换可能代价高（如果数据域大）。所以，我们分别实现逆置和插入排序。由于用户没有指定编程语言，我们使用C语言风格实现。定义链表节点：typedefstructNode{intdata;structNode*next;}Node,*LinkList;头结点：LinkListhead;head->next指向第一个节点（可能为空）。逆置函数（头插法）：voidReverse(LinkListhead){//如果链表为空或只有一个节点，直接返回if(head->next==NULL||head->next->next==NULL){return;}Node*p=head->next;//第一个节点head->next=NULL;//将头结点next置空Node*q;while(p!=NULL){q=p->next;//保存下一个节点p->next=head->next;//将当前节点插入到头结点之后head->next=p;p=q;}}直接插入排序：voidInsertSort(LinkListhead){//空表或只有一个节点，直接返回if(head->next==NULL||head->next->next==NULL){return;}Node*sorted=head->next;//已排序链表的第一个节点（也是已排序部分的最后一个节点）Node*curr=sorted->next;//从第二个节点开始，即未排序部分的第一个节点sorted->next=NULL;//断开，有序链表只有一个节点while(curr!=NULL){Node*next=curr->next;//保存curr的下一个节点//在有序链表（head开头）中寻找插入位置Node*prev=head;//插入位置的前驱节点，初始为头结点Node*p=head->next;//有序链表的第一个节点while(p!=NULL&&p->data< curr->data){prev=p;p=p->next;}//在prev和p之间插入currprev->next=curr;curr->next=p;//更新curr到下一个待插入节点curr=next;}}注意：上述插入排序过程中，我们每次将未排序部分的第一个节点取出插入到有序部分，所以叫做直接插入排序。用户要求实现的是带头结点的单链表，所以以上两个函数均符合。另外，用户可能会问这两种操作的时间和空间复杂度：逆置：时间复杂度为$O(n)$，空间复杂度$O(1)$。直接插入排序：时间复杂度为$O(n^2)$，空间复杂度$O(1)$。现在，将完整代码（包括逆置和插入排序）整理如下：</think> 以下是带表头节点的单链表实现**逆置**和**排序**的详细方法： ### 一、单链表结构定义（C语言） ```c typedef struct Node { int data; // 数据域 struct Node* next; // 指针域 } Node; typedef struct { Node* head; // 头节点指针 } LinkList; ``` --- ### 二、链表逆置实现 #### 方法1：三指针遍历法（原地逆置） ```c void Reverse(LinkList* L) { if (L->head->next == NULL || L->head->next->next == NULL) return; // 空表或单节点无需逆置 Node* p = L->head->next; // 首元节点 Node* q = p->next; Node* r = NULL; p->next = NULL; // 首元节点转为尾节点 while (q != NULL) { r = q->next; // 暂存后继节点 q->next = p; // 逆置指针 p = q; // 指针后移 q = r; } L->head->next = p; // 头节点指向新首元节点 } ``` **原理**： 通过三个指针`p`、`q`、`r`逐步反转指针方向，时间复杂度$O(n)$，空间复杂度$O(1)$[^2]。 #### 方法2：头插法（推荐） ```c void Reverse_HeadInsert(LinkList* L) { Node* p = L->head->next; L->head->next = NULL; // 头节点暂时置空 while (p) { Node* tmp = p->next; // 暂存后继 p->next = L->head->next; // 头插操作 L->head->next = p; p = tmp; // 继续处理下一节点 } } ``` **优势**： 代码更简洁，适用于教学和工程实践[^2]。 --- ### 三、链表排序实现 #### 方法1：直接插入排序 ```c void InsertSort(LinkList* L) { if (L->head->next == NULL) return; Node* sorted = L->head->next; // 有序链表头部 Node* unsorted = sorted->next; // 待排序链表头部 sorted->next = NULL; // 断开有序/无序链表 while (unsorted) { Node* curr = unsorted; unsorted = unsorted->next; // 寻找插入位置 Node* prev = L->head; // 从表头开始遍历 while (prev->next && prev->next->data < curr->data) { prev = prev->next; } // 插入节点 curr->next = prev->next; prev->next = curr; } } ``` **特点**： 时间复杂度$O(n^2)$，空间复杂度$O(1)$，稳定排序[^1]。 #### 方法2：冒泡排序（交换数据域） ```c void BubbleSort(LinkList* L) { if (L->head->next == NULL) return; int len = 0; for (Node* p = L->head->next; p; p = p->next) len++; for (int i = 0; i < len - 1; i++) { Node* p = L->head->next; for (int j = 0; j < len - i - 1; j++) { if (p->data > p->next->data) { // 交换数据域 int temp = p->data; p->data = p->next->data; p->next->data = temp; } p = p->next; } } } ``` **适用场景**： 当链表节点数据域较小时使用[^3]。 --- ### 四、关键差异分析 | **操作** | **实现方式** | **时间复杂度** | **空间复杂度** | **链式结构修改** | |----------|---------------------|----------------|----------------|------------------| | 逆置 | 三指针/头插法 | $O(n)$ | $O(1)$ | 修改指针 | | 排序 | 插入排序(推荐) | $O(n^2)$ | $O(1)$ | 修改指针 | | 排序 | 冒泡排序 | $O(n^2)$ | $O(1)$ | 仅交换数据 | --- ### 五、总结建议 1. **逆置优先选择头插法**：逻辑清晰，代码简洁 2. **排序优先选择插入排序**：真正修改链式结构，避免大块数据交换 3. 排序优化方向：结合归并排序可达到$O(n \log n)$时间复杂度 > 所有实现均基于带头节点的单链表结构，头节点不存储数据，仅用于简化边界处理[^1][^2][^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值