逆序操作专题03——双向链表的逆序操作（面试题编程）

最新推荐文章于 2024-01-03 16:05:58 发布
最新推荐文章于 2024-01-03 16:05:58 发布
阅读量777 收藏 4
点赞数 1
分类专栏： 04数据结构课程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boyaaboy/article/details/102644428
版权

参考
博文01：https://blog.csdn.net/shltsh/article/details/46486945
博文02：https://blog.csdn.net/qiao_yuzhou/article/details/6165969
博文03：https://blog.csdn.net/autumn20080101/article/details/7607148

一、双向链表(3) - 反转双向链表（博文01）

双向链表的反转过程，可以参考下面的例图：

(a) 原始双向链表
在这里插入图片描述

(b) 反转后的双向链表（注意指针指向的变化）
在这里插入图片描述
注意：（记忆下面的话和上面的图）
（1）上图中最大的变化，也是最本质的变化是各个节点的前后指针域的指向发生了变化。
（2）数据结构中一般用结构体指针来指向结点，如果一个指针pointer指向结点P，那么你就可以把指针pointer和p看做是一个事物，即同一个结点。
（3）实际上数据结构的程序中大多数都是用**结构体指针（结构体类型的指针）**来表示结点的，你很少看到不是指针的结构体来表示结点
特别注意：结构体指针是有成员变量的，如head结构体指针有三个成员变量。

（4）本例中 head结构体指针始终指向头结点：
特别注意：结构体指针是有成员变量的，如head结构体指针有三个成员变量。

typedef struct node
{
	int data;
	struct node *next; // 指向下一个节点
	struct node *prev; // 指向前一个节点
}node;

node* head = NULL;
需要记忆的核心代码：（下面代码一定要理解记忆，多动手）

重点记忆：
（1）函数中共有三个结构体指针,分别表示头结点，临时结点和当前结点，
注意：其中这里函数形参head是二级结构体指针，是一个传出参数，要通过调用函数改变一级结构体指针的值，所以就用到了二级指针
（2）循环遍历的终止条件是：while (current != NULL)
（2）current一次挪动一个结点：current = current->prev; //3–>2–>1, current指向的位置变为0，继续往后循环。

//对链表进行反转
void reverse(node **head)
{
	node *temp = NULL;
	node *current = *head;      //相同数据类型的变量才能相互赋值

//交换每个节点的后向指针和前向指针
	// 1-->2-->3
	//10<->8<->6<->4<->2<->0, 假设2为current.
	while (current != NULL)
	{
		temp = current->prev; //temp指针指向4
		current->prev = current->next; // current的前向指针指向0
		current->next = temp;            // current的后向指针指向4
		current = current->prev; //3-->2-->1, current指向的位置变为0，继续往后循环。
	}
	//总结：先处理前向指针，然后处理后向指针。这些操作都只对当前节点(current),不涉及其它节点。
	//1.缓存前向指针
	//2.将后向指针赋值给前向指针
	//3.将缓存的前者指针，赋值给后向指针
	//4.当前节点指针移动到下一个待处理节点
	//5.让头结点结构体指针head指向头结点

    //5.让头结点结构体指针head指向头结点
	//修改头指针之前，先检测链表是否为空链表，或者只有一个节点的情况
	if (temp != NULL)
		*head = temp->prev; //  temp->prev就相当于current->prev->prev，当然这里current是指向0的时候，那么current->prev  就指向结点2，current->prev->prev指向结点0（因为此时已将反转了前向指针）
	printList(temp->prev);
}

下面是一个用于反转双向链表的简单方法。所需要做的事情就是交换每个节点的前向指针和后向指针，然后调整链表的头结点指针head和尾指针。

#include <iostream>
using namespace std;
typedef struct node
{
	int data;
	struct node *next; // 指向下一个节点
	struct node *prev; // 指向前一个节点
}node;

// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的头部  
// 之所以传入双指针，因为函数中需要修改链表  
void push(node** head, int newData)
{
	//1. 分配新节点内存  
	node* newnode = new node;

	//2. 赋值  
	newnode->data = newData;

	//3. 将原始头节点做为新节点的后向指针，而前向指针置为NULL  
	newnode->next = (*head);
	newnode->prev = NULL;

	//4. 将原始头节点的前向指针置为新的节点  
	if ((*head) != NULL)
		(*head)->prev = newnode;

	//5. 将头指针置为新的节点,头指针永远指向第一个结点  
	(*head) = newnode;
}

void printList(node *head)
{
	while (head != NULL)
	{
		std::cout << " " << head->data << " ";
		head = head->next;
	}
	std::cout << std::endl;
}
//对链表进行反转
void reverse(node **head)
{
	node *temp = NULL;
	node *current = *head;      //相同数据类型的变量才能相互赋值

//交换每个节点的后向指针和前向指针
	// 1-->2-->3
	//10<->8<->6<->4<->2<->0, 假设2为current.
	while (current != NULL)
	{
		temp = current->prev; //temp指针指向4
		current->prev = current->next; // current的前向指针指向0
		current->next = temp;            // current的后向指针指向4
		current = current->prev; //3-->2-->1, current指向的位置变为0，继续往后循环。
	}
	//总结：先处理前向指针，然后处理后向指针。这些操作都只对当前节点(current),不涉及其它节点。
	//1.缓存前向指针
	//2.将后向指针赋值给前向指针
	//3.将缓存的前者指针，赋值给后向指针
	//4.当前节点指针移动到下一个待处理节点
	//5.让头结点结构体指针head指向头结点

    //5.让头结点结构体指针head指向头结点
	//修改头指针之前，先检测链表是否为空链表，或者只有一个节点的情况
	if (temp != NULL)
		*head = temp->prev; //  temp->prev就相当于current->prev->prev，当然这里current是指向0的时候
	printList(temp->prev);
}

int main()
{
	//初始化链表为：10<->8<->6<->4<->2<->0
	node* head = NULL;
	push(&head, 0);
	cout << head->next << endl;
	push(&head, 2);
	cout << head->next << endl;
	push(&head, 4);
	cout << head->next << endl;
	push(&head, 6);
	push(&head, 8);
	push(&head, 10);

	std::cout << "Original DLL is: ";
	printList(head);
	
	reverse(&head);

	std::cout << "Reversed DLL is: ";
	printList(head);
	

	
	return 0;
}

时间复杂度：O(n)

二、C语言实现（博文02）

题目：创建一个双链表，然后逆置双链表。

程序分析：将双链表逆置，即是将双链表中的元素逆置，依次将双链表的结点按照头插法插入到一个新建链表的首位，即可实现双链表元素的逆置

代码如下：

#include<stdio.h>

#include<malloc.h>

typedef struct node

{

char name[20];

struct node *prior,*next;

}stud;

stud *creat(int n)/创建链表/

{

stud *p,*h,*s;

int i;

h=(stud *)malloc(sizeof(stud));/动态分配内存/

h->name[0]=’/0’;

h->prior=NULL;

h->next=NULL;

p=h;/p始终用来指向链表的最后一个结点/

printf("/n输入结点：/n");

for(i=1;i<=n;i++)

{

printf(“请输入第%d个结点/n”,i);

s=(stud *)malloc(sizeof(stud));

p->next=s;/通过p->next=s，将s链入链表/

scanf("%s",s->name);

s->prior=p;/s的前驱指向p，将s链入链表/

s->next=NULL;/在s链入链表时成为最后一个结点，所以s的后继为NULL/

p=s;/p始终指向链表的最后一个结点/

}

p->next=NULL;/链表的最后一个结点的后继为NULL/

return (h);

}

/*逆置双链表的原理，依次将原链表中的结点

用头插法插入到新的链接表中,新的链表不用分配内存*/

stud *reverse(stud *head)

{

stud *p,*r,*h;

/*

p用来指向原链表中的第一个结点，待链入新链表头的结点

r用来指向原链表中的第二个结点

h用来指向新链表中的第一个结点

*/

h=head->next;/h用来指向链表的第一个结点/

if(h&&h->next)

{

p=h;

r=p->next;/r指向p的下一个结点/

p->next=NULL;/让p的下一个结点为NULL/

while®

{

p=r;/p指向r结点/

r=r->next;/r继续指向下一个结点/

p->next=h;/p的后继指向链表的第一个结点h/

h->prior=p;/链表的第一各结点h的前驱指向p/

h=p;/p链入链表后，p就成为了链表的第一个结点/

}

head->next=h;/头结点head的后继指向新链表的第一个结点h/

h->prior=head;/新链表的第一结点h的前驱指向头结点head/

return head;

}

}

void dip(stud *q)/显示链表/

{

while(q)

{

printf("%s ",&*(q->name));/输出结点的内容/

q=q->next;/指向下一个结点/

}

}

void main()

{

int n;

int x;

stud *q;

printf("/n你想创建的链表的长度：/n");

scanf("%d",&n);

q=creat(n);/创建链表/

printf("/n原始链表为：/n");

dip(q);

q=reverse(q);/逆置链表/

printf("/n逆置后的结果链表为：/n");

dip(q);

printf("/n");

}

题目：创建双链表，对其中的数据逆序输出

程序分析：因为双链表有两个指针域：

既可以利用后继指针，从头结点出发遍历到尾结点的指针链，

也可以利用前驱指针，从尾结点出发遍历到头结点的指针链。

这样就可以实现逆序查找双链表结点，并将结点数据域的数据信息输出。

代码如下：

#include<stdio.h>

#include<malloc.h>

typedef struct node

{

char name[20];

struct node *prior,*next;

}stud;

/双链表的结构定义/

stud *creat(int n)/创建链表/

{

stud *p,*h,*s;

/*

p用来指向链表中的最后一个结点，

h用来指向链表的头结点，

s用来指向新建的结点

*/

int i;

h=(stud *)malloc(sizeof(stud));

h->name[0]=’/0’;

h->next=NULL;

h->prior=NULL;

p=h;

printf("/n输入结点:/n");

for(i=1;i<=n;i++)

{

s=(stud *)malloc(sizeof(stud));

p->next=s;/p结点的后继指向s/

printf(“请输入第%d个结点的数据：”,i);

scanf("%s",s->name);

s->prior=p;/s的前驱指向p，这样s称为链表的最后一个结点/

s->next=NULL;/s的后继为NULL/

p=s;/p指向s结点，这样p指向了链表的最后一个结点/

}

p->next=NULL;/链表的最后一个结点的后继为NULL/

return (h);

}

stud *gettp(stud *head)/查找最后一个结点/

{

stud *p;

p=head;

while(p->next!=NULL)/尾结点的后继为NULL/

p=p->next;

return p;

}

void main()

{

int n;

stud *q;

printf(“请输入要创建的链表的长度：”);

scanf("%d",&n);

q=creat(n);

q=gettp(q);

printf("/n逆序输出链表：/n");

while(q)

{

printf(" %s",&*(q->name));

q=q->prior;/从尾结点开始利用其直接前驱向前遍历链表的结点/

}

printf("/n");

}

博雅勇士
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
逆序操作专题02——递归和循环两种方法实现单链表逆序（本篇文章优秀）
博雅勇士的博客
11-04 353
参考 博文01：https://blog.csdn.net/u012124604/article/details/39344483 一、 单链表逆序 经典的“单链表逆序”问题。很多公司的面试题库中都有这道题，有的公司明确题目要求不能使用额外的节点存储空间，有的没有明确说明，但是如果面试者使用了额外的节点存储空间做中转，会得到一个比较低的分数。如何在不使用额外存储节点的情况下使一个单链表的所有节点逆...
经典面试题之逆序打印链表
weixin_43658027的博客
10-08 134
前几天面试，遇到这样一个题目！！ 题目：输入一个链表的头节点，从头到尾反过来打印每个节点的值。 解题方法：运用递归算法 代码实现如下： #include<iostream> #include<malloc.h> using namespace std; typedef struct node { int val; struct node *next; }node, *Linklist; void _print(Linklist head) { Linkli
数据结构 之 链表 高频面试题
CSNZのBlog
10-11 3289
一：面试时链表解题的方法论 1、对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2、对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法 二：链表面试题常用数据结构和技巧 1、使用容器（哈希表、数组等） 2、快慢指针 使用快慢指针的面试题： 1、输入链表头结点，奇数长度返回中点，偶数长度返回上中点 * //输入链表头结点，奇数长度返回中点，偶数长度返回上中点 public static <T> Node<T> midOrUpMidNode(Node<T&g
逆序操作专题01单链表逆序——单链表逆序操作与逆序输出实例 C语言实现（常考面试题编程）
博雅勇士的博客
10-25 571
参考博文01：https://blog.csdn.net/win_turn/article/details/50691562 一、正确的学习方法 1、要想学好数据结构，先画图思考算法理解算法，然后在图上写上核心代码： 2、（1）画图理解（2）记忆核心代码实现 面试常考 二、 3、单链表的逆序输出分为两种情况，一种是只逆序输出，实际上不逆序；另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体...
【面试题】链表的逆序操作
weixin_42282031的博客
09-04 169
面试最常见的笔试题目，链表的反转 其中一次竟然碰到一个面试官让我现场写单链表反转，要求链表头指针不动，数据逆序。当时好像写的有问题，现在整理了一下，用了递归函数，解决了。 贴上源码： #include <stdio.h> #include <stdlib.h> typedef struct list_node { int data; struct list_node *next; }list_t; static struct list_node *create_node(in
Leetcode面试经典150题刷题记录 —— 链表篇
键盘国治理专家的博客
01-03 1076
Leetcod面试经典150题刷题记录 —— 链表篇
LeetCode链表逆序：翻转策略面试最简代码综合运用
击水三千里的专栏
02-14 408
主要讨论面试环境下的最简洁写法
数据结构（Java）——链表面试题
FallToHer的博客
09-22 137
链表面试题 一、求链表中的有效节点 思路：就是将链表的相关信息进行遍历，找个数据自加 代码如下 //找有效节点的个数 public static int getLength(HeroNode head) { if(head.next == null) { //空链表 return 0; } int length = 0; //定义一个辅助的变量 HeroNode cur = head.next; while(cur != null) { length++;
面试题—逆序打印链表各节点的值（递归和非递归）
qq_39241239的博客
07-12 541
逆序输出链表结点的值 例如：head-&gt;3-&gt;2-&gt;5-&gt;8-&gt;4-&gt;7-&gt;6-&gt;9-&gt;0-&gt;1 输出为 ： 1   0   9   6   7   4   8   5   2   3 代码如下： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 10 type
面试题:用 Java 逆序打印链表
08-27
在了解链表逆序打印之前，首先需要了解链表的基本概念。链表是一种数据结构，其中每个元素指向下一个元素，以便形成一个链式结构。链表有多种类型，如单链表、双向链表、环链表等。在 Java 中，链表可以通过 Node 类...
leetcode算法题-链表操作（两数相加）
12-20
在LeetCode上，有一道经典的算法题，名为“两数相加”（Add Two Numbers）。题目要求使用两个非空的链表来表示...通过解决此类问题，可以提升编程能力和算法思维，对于面试和日常工作中的数据结构处理都有很大的帮助。
为面试做准备的python经典编程题之3
最新发布
01-09
二叉搜索树与双向链表.py 序列化二叉树.py 字符串的排列.py 数组中出现次数超过一半的数字.py 最小的k个数.py 连续子数组的最大和.py n整数中1出现的次数.py 数字序列中的某一位数字.py 把数组拍成最小的数字.py 把...
面试常见编程题汇总包含快排，二分查找
08-22
在IT行业的面试中，编程题是衡量候选人技术能力的重要标准，尤其对于Java程序员来说，熟练掌握基础算法和数据结构是必不可少的。本资料"面试常见编程题汇总包含快排，二分查找"聚焦于两个经典的算法：快速排序...
算法实现：Java单链表逆序
09-01
有一次，我去陆家嘴一家银行面试，面试官给我出了一道算法编程题，用Java实现单链表逆序，不到10分钟，我就写出来了，拿到了offer。 但是当时是写在纸上的，我用手机拍了下来，然后回去又在电脑上把代码敲了下来，...
递归专题 01篇——超经典递归算法原理和实现时的经验总结 （4）经典递归问题实战（面试常考）
博雅勇士的博客
11-02 1386
目录一、引言3、上面的比喻形象地阐述了递归与循环的内涵，那么我们来思考以下几个问题：二、递归的原理和概念4、递归的三要素（极其重要）5、递归算法的编程模型6、递归的应用场景三. 递归与循环四. 经典递归问题实战第一类问题：问题的定义是按递归定义的(1). 阶乘(2). 斐波纳契数列(4). 回文字符串的判断(5). 字符串全排列(6). 二分查找第二类问题：问题解法按递归算法实现(1). 汉诺塔问...
数据结构与算法的应用场景
博雅勇士的博客
10-31 987
参考 博文01：https://www.cnblogs.com/muyangshaonian/p/9650554.html 博文02：https://www.cnblogs.com/lz3018/p/5932198.html 博文01 常用数据结构的应用场景 1、单向链表 单向链表适用于只从一端单向访问的场合，这种场合一般来说： （1）、删除时，只适合删除第一个元素； （2）、添加时，只直接添加到...
第8章查找——哈希表（散列表）原理详解（大话数据结构）
博雅勇士的博客
10-31 740
一、概念 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)...
01学习数据结构最最重要的理解点——学会之后就所向披靡
博雅勇士的博客
10-19 696
一、介绍 1、本篇文章记录于2019.10.19日，看了一个程序看了两个小时才弄明白，特此记录下来。 二、数据结构学习理解重点 1、假设P是指向双向链表中第i个元素的指针， （1）则该结点ai的数据我们可以用P->data来表示，P->data的值是一个数据元素 （2）结点ai的指针域可以用p->next来表示，p->next的值是一个指针 2、那么p->next指向...
"2023阿里Java面试题：实现高效单向链表逆序输出
这是一道经典的面试题，考察对链表数据结构以及指针操作的理解和应用。在这道题中，我们需要实现一个函数，能够将单向链表逆序输出，即将链表的指针方向反转，并从尾到头输出链表的元素。 为了实现这个功能，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值