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

于 2019-10-19 23:12:58 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： 04数据结构课程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/boyaaboy/article/details/102644428
版权

参考
博文01：https://blog.youkuaiyun.com/shltsh/article/details/46486945
博文02：https://blog.youkuaiyun.com/qiao_yuzhou/article/details/6165969
博文03：https://blog.youkuaiyun.com/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");

}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值