C/C++ 《剑指offer》——（3）从尾到头打印链表

最新推荐文章于 2022-10-28 10:00:00 发布
最新推荐文章于 2022-10-28 10:00:00 发布
阅读量201 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37898962/article/details/99186118
版权

问题描述：

输入一个链表，按链表值从尾到头的顺序打印结点值。

解题思路及知识点

由题意选择三种思路：

  • 采用循环方法从尾到头打印单链表
  • 采用递归方法从尾到头打印单链表
  • 借助栈的特性从尾到头打印单链表

链接方式存储的线性表简称为链表（Linked List），data域--存放结点值的数据域，next域--存放结点的直接后继的地址（位置）的指针域（链域），链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的，每个结点只有一个链域的链表称为单链表（Single Linked List）。

typedef struct node{ //结点类型定义

DataType data; //结点的数据域

struct node *next;//结点的指针域

}ListNode，*LinkList;
  • LinkList和ListNode是不同名字的同一个指针类型（命名的不同是为了概念上更明确）；
  • *LinkList类型的指针变量head表示它是单链表的头指针；
  • ListNode类型的指针变量p表示它是指向某一结点的指针；
  • 生成结点变量的标准函数

p=( ListNode *)malloc(sizeof(ListNode))；//函数malloc分配一个类型为ListNode的结点变量的空间,将其首地址放入指针变量p中

单链表的建立有头插法、尾插法两种方法。

头插法

从一个空表开始，每次读入数据，生成新结点，将读入数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头结点之后，直至读入结束标志为止。头插法建表过程如下图所示：

尾插法

头插法建立链表虽然算法简单，但生成的链表中结点的次序和输人的顺序相反。若希望二者顺序一致， 可采用尾插法建表。 该方法是将新结点插到当前单链表的表尾上。为此需增加一个尾指针r,使之指向当前单链表的表尾。在这里采用尾插法建立单链表，尾插法建表过程如下图所示：

 栈（stack）又名堆栈，它是一种运算受限的线性表，特点“后进先出”。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

  • 进栈（PUSH）算法

①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）；

②置TOP=TOP+1（栈指针加1，指向进栈地址）；

③S(TOP)=X，结束（X为新进栈的元素）；

  • 退栈（POP）算法

①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作②)；

②X=S(TOP)，（退栈后的元素赋给X）：

③TOP=TOP-1，结束（栈指针减1，指向栈顶）。

思路一：采用循环方法从尾到头打印单链表

该方法为定义一个自己需要找到的指针，最开始为NULL;然后每当找到一个位置时该指针前移，直至找到头指针。

#include<stdio.h>
#include<stdlib.h>
typedef struct node            //结点类型定义
{
	int data;
	struct node* next;
}node,*list;                 //list为结构指针类型
void csh(list *l)				//初始化单链表
{
	*l = (list)malloc(sizeof(node));     //建立头结点
	(*l) ->next = NULL;					//建立空的单链表
}
void wcjb(list l,int i)          //尾插法建立单链表
{
	node *r, *s;              
	s =(node*)malloc(sizeof(node));         //建立新节点
	if (s == NULL) //验证空间申请是否成功
	{
		printf("内存分配失败\n");
		return;      //若分配内存不成功，则返回继续分配。
	}
	r = l;
	while (r->next)    //找到最后一个节点
	{
		r = r->next;
	}
	s->data = i;         
	r->next = s;            //将s结点插入表尾
	s->next = NULL;
}
void xhfxdy(list l)
{
	node *r, *h;
	r = NULL;
	if (l == NULL)          //判断输入链表是否为空
	{
		printf("\n\t原链表为空请重新输入\n\n");
		return;
	}
	printf("采用循环方法从尾到头打印单链表：\t");
	while(r !=l)          //在从尾到头前执行循环，直到到头结点
	{
		h = l;
		while (h->next!= r)      //当未找到自己需要的结点时执行循环
		{
			h = h->next;
		}
		if (h == l)
		{
			printf("\n");
			return;
		}
		printf("%d\t", h->data);     
		r = h;                //每次指定自己需要找得节点位置
	}
	
}
void dylb(list l)      //顺序打印输入的链表，为验证链表建立的正确性，可自行删除
{
	node *r;
	r = l ->next;
	printf("顺序打印通过尾插法建立的单链表:\t\t");
	while (r)                     //执行循环输出每个节点值
	{
		printf("%d\t", r->data);
		r = r->next;
	}
	printf("\n\n");
}
int main()
{
	node *l;               //定义及初始化链表
	csh(&l);
	wcjb(l, 1);                 //尾插法建表
	wcjb(l, 3);
	wcjb(l, 2);
	wcjb(l, 4);
	wcjb(l, 8);
	wcjb(l,6);
	wcjb(l, 5);
	dylb(l);
	xhfxdy(l);             //采用循环方法从尾到头打印单链表
	xhfxdy(NULL);      //验证链表为空
	return 0;
}

 思路二：采用递归方法从尾到头打印单链表

该方法为通过递归找到表尾，然后依次向前输出，直至头指针。

#include<stdio.h>
#include<stdlib.h>
typedef struct node            //结点类型定义
{
	int data;
	struct node* next;
}node,*list;                 //list为结构指针类型
void csh(list *l)				//初始化单链表
{
	*l = (list)malloc(sizeof(node));     //建立头结点
	(*l) ->next = NULL;					//建立空的单链表
}
void wcjb(list l,int i)          //尾插法建立单链表
{
	node *r, *s;              
	s =(node*)malloc(sizeof(node));         //建立新节点
	if (s == NULL) //验证空间申请是否成功
	{
		printf("内存分配失败\n");
		return;      //若分配内存不成功，则返回继续分配。
	}
	r = l;
	while (r->next)    //找到最后一个节点
	{
		r = r->next;
	}
	s->data = i;         
	r->next = s;            //将s结点插入表尾
	s->next = NULL;
}
void dgfxdy(list l,list l1)
{
	if (l== NULL)         //判断输入链表是否为空
	{ 
		printf("\n\t原链表为空请重新输入\n\n");
		return;
	}
	if (l->next != NULL)   //找到最后一个节点
	{
		dgfxdy(l->next,l1);
		printf("%d\t", l->next->data);   //通过递归实现从尾到头输出
	}
	if (l->next == NULL)
	{
		printf("采用递归方法从尾到头打印单链表：\t");
	}
	if(l==l1)                  //为了最后测试结果清晰，可选择删除
		printf("\n");
}
void dylb(list l)      //顺序打印输入的链表，为验证链表建立的正确性，可自行删除
{
	node *r;
	r = l ->next;
	printf("顺序打印通过尾插法建立的单链表:\t\t");
	while (r)                     //执行循环输出每个节点值
	{
		printf("%d\t", r->data);
		r = r->next;
	}
	printf("\n\n");
}
int main()
{
	node *l;               //定义及初始化链表
	csh(&l);
	wcjb(l, 1);                 //尾插法建表
	wcjb(l, 3);
	wcjb(l, 2);
	wcjb(l, 4);
	wcjb(l, 8);
	wcjb(l,6);
	wcjb(l, 5);
	dylb(l);
	dgfxdy(l, l);        //采用递归方法从尾到头打印单链表
	dgfxdy(NULL, NULL);   //验证链表为空
	return 0;
}

 思路三：借助栈的特性从尾到头打印单链表

该方法为借助栈的特性“后进先出”，将链表数据域从头到尾依次压入栈中，然后再进行出栈。

#include<iostream>
#include<cstdlib>
#include<stack>
using namespace std;
typedef struct node            //结点类型定义
{
	int data;
	struct node* next;
}node, *list;                 //list为结构指针类型
void csh(list *l)				//初始化单链表
{
	*l = (list)malloc(sizeof(node));     //建立头结点
	(*l)->next = NULL;					//建立空的单链表
}
void wcjb(list l, int i)          //尾插法建立单链表
{
	node *r, *s;
	s = (node*)malloc(sizeof(node));         //建立新节点
	if (s == NULL) //验证空间申请是否成功
	{
		printf("内存分配失败\n");
		return;      //若分配内存不成功，则返回继续分配。
	}
	r = l;
	while (r->next)    //找到最后一个节点
	{
		r = r->next;
	}
	s->data = i;
	r->next = s;            //将s结点插入表尾
	s->next = NULL;
}
void dylb(list l)      //顺序打印输入的链表，为验证链表建立的正确性，可自行删除
{
	node *r;
	r = l->next;
    cout<<"顺序打印通过尾插法建立的单链表:\t\t"
	while (r)                     //执行循环输出每个节点值
	{
		printf("%d\t", r->data);
		r = r->next;
	}
	printf("\n\n");
}
void jzfxdy(list l)
{
	if (l == NULL)          //判断输入链表是否为空
	{
		cout<< "\n\t原链表为空请重新输入\n"<<endl;
		return;
	}
	node* p ;
	p = l;
	stack<int>a;                  //定义一个容器a
	while (p)                     //将链表从头到尾依次压入栈
	{
		a.push(p->data);
		p = p->next;
	}
	cout << "借助栈的特性从尾到头打印单链表：\t";
	int len = a.size();           //栈元素个数
	for (int i = 1; i < len; i++)    //出栈即从尾到头打印原链表
	{
		cout << a.top()<<"\t";
		a.pop();
	}
	cout<<"\n\n";
}
int main()
{
	node *l;               //定义及初始化链表
	csh(&l);
	wcjb(l, 1);                 //尾插法建表
	wcjb(l, 3);
	wcjb(l, 2);
	wcjb(l, 4);
	wcjb(l, 8);
	wcjb(l, 6);
	wcjb(l, 5);
	dylb(l);
	jzfxdy(l);        //采用递归方法从尾到头打印单链表
	jzfxdy(NULL);   //验证链表为空
	return 0;
}

牛客网在线编程剑指offer测试通过

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
	vector<int> printListFromTailToHead(ListNode* head) {
		vector <int>  result;
		stack<int> arr;
		ListNode* p = head;
		while (p)
		{
			arr.push(p->val);
			p = p->next;
		}
		int len = arr.size();
		for (int i = 0; i < len; i++)
		{
			result.push_back(arr.top());
			arr.pop();
		}
		return  result;
	}
};

注意问题：

  • 在查找时要注意链表为NULL的情况；
  • 建立新结点需调用函数malloc， 头文件要加 #include<stdlib.h>；
  • 此处建立的是带头结点的单链表，输出结果时要去除头结点；
  • 使用stack<int> a函数需要添加头文件  #include<stack>。

 

 

 

      请多多指教！如发现有错误，请及时告知。谢谢！

      有疑问可评论或者私信，在能力范围内有问必答！

yuanzhaoup
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言】【链表】尾插法创建一个链表，并在指定位置插入一个结点
新手小白
06-30 996
Oj 期末考试倒数第二题 需要分类讨论 注意细节
数据结构，尾插法创建单链表（C）
像鱼的博客
05-02 685
#include <stdio.h> #include <stdlib.h> // 链表结构定义 typedef struct Node { int data; struct Node* next; }Node,*LinkList; // 初始化链表 LinkList initList_2() { LinkList L = (Node *) malloc (sizeof(Node)); L->next=NULL; return L;.
【数据结构实验】链表
最新发布
PWrose的博客
10-28 1122
3.（附加题）对任务1或者2中创建的某一个单链表{A1,B1,A2,B2,…,An,Bn}，编写一个算法将它拆分为两个单链表，分别为：{A1,A2,…,An}和{Bn,…2.在main()函数中，调用头插法（CreateListF()函数）和尾插法（CreateListR()函数），创建新链表，并输出结果进行比较；1.实现单链表各种基本运算的算法；
【数据结构】单链表操作（C++版），利用头插法或尾插法建立单链表；对已建立的单链表实现插入、删除等基本操作；输出链表所有结点数据；编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长
qq_52978240的博客
11-07 3032
单链表操作 一、实验目的: 熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本 思想，能够根据实际情况选择合适的存储结构。 二、实验要求: 算法完善，考虑时间复杂度。 三、实验内容: 1、利用头插法或尾插法建立单链表; 2、对已建立的单链表实现插入、删除等基本操作; 3、输出链表所有结点数据; 4、编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长，要求利用原来两个单链表的结点存放归并后的单链表。定义单链表 typedef struct LNode{ int dat
数据结构（使用尾插法实现单链表）
DMHY123的博客
07-20 3626
1.线性表的链式存储就是单链表，单链表通过一组任意的存储单元来存储线性表的数据元素（逻辑相邻，存储离散），单链表对于每一个链表结点，不但存储自身数据，还开辟了存储一个指向后继结点的指针。优点解决了顺序表需要大量连续存储单元的问题，单链表的数据元素离散的分布在存储空间中。3.建立单链表可以使用头插法和尾插法两种操作，其中头插法创建的单链表数据有逆置效果。4.创建单链表可以使用头结点方便编码，也可以不使用头结点，本代码使用了头结点。缺点需要额外的存储空间存放指针域。...
剑指Offer #03 从尾到头打印链表（递归）
01-20
题目地址：从尾到头打印链表 题目描述 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 题目解析 方法一： 因为题目要求返回的顺序是从尾到头，所以我们可以采用递归的形式访问链表，在回归的过程才将节点的...
stronglxp#learnNote#剑指 Offer 06. 从尾到头打印链表1
07-25
剑指 Offer 06. 从尾到头打印链表链接：
《剑指Offer》刷题笔记——面试题06. 从尾到头打印链表
01-21
1、剑指解析： 2、代码实现： I、辅助栈 from typing import List ###### 代码主体 ###### class Solution: def reversePrint(self, head: ListNode) -> List[int]: stack = [] if head is None: return [] ...
Trouvaille0198#Notes#剑指 Offer 06. 从尾到头打印链表1
07-25
剑指 Offer 06. 从尾到头打印链表输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。示例 1：输出：[2,3,1]辅助栈// 辅助栈s
利用尾插法建立单链表
m0_52148779的博客
10-29 5659
PTA 5-3本题目要求利用尾插法建立单链表 #输入格式： 输入数据为若干正整数，最后以-1表示结尾（-1不算在序列内，不要处理）。所有数据之间用空格分隔。 #输入样例： 1 2 3 4 5 6 7 8 9 -1 #输出样例： 1 2 3 4 5 6 7 8 9 代码如下： #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data;
尾插法建立单链表
热门推荐
weixin_52634719的博客
09-20 1万+
要用到尾指针r 示意图如下： 关键步骤： 1先在内存中把新结点找出来，然后给新结点的数据域赋值，然后它的指针域为空 再把新结点接在尾结点的后头，也就是要给尾结点的指针域赋值r->next=p； 然后新插入的结点就是新的尾结点了，所以要移动指针r=p，让指针指向新的尾结点 接下来就可以继续操作下一个了：再在内存当中找到这样一块空间，开辟一个新的结点，然后将新结点记在我们尾结点的后头，然后让新结点变成新的尾结点，这样反复来做，直到所有的结点都插入到链表当中。 ...
c语言 链表尾插法实现,用尾插法实现单链表整表创建
weixin_36240211的博客
05-21 2072
昨天我们谈到了头插法，可事实上，我们还是可以不这样干，为什么不把新结点都放到最后呢，这才是排队时的正常思维，所谓的先来后到。我们把每次新结点都插在终端结点的后面，这种算法称之为尾插法。/* 随机产生n个元素的值，建立带表头结点的单链线性表L(尾插法) */void CreateListTail(LinkList *L, int n){LinkList p,r;int i;srand(time(0...
C语言头插法尾插法创建单链表
weixin_62503503的博客
08-21 5495
链表 [Linked List]：链表是由一组不必相连【不必相连：可以连续也可以不连续】的内存结构 【节点】，按特定的顺序链接在一起的抽象数据类型。头插法和尾插法建立单链表步骤很相似，而尾插法需要将新插入的节点重新设为尾节点，以上就是两种方法创建单链表。
数据结构实验之链表三：链表的逆置
king9666的博客
03-07 386
数据结构实验之链表三：链表的逆置 Problem Description 输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。 Input 输入多个整数，以-1作为结束标志。 Output 输出逆置后的单链表数据。 Sample Input 12 56 4 6 55 15 33 62 -1 Sample Output 62 33 ...
浙大数据结构，尾插建立链表
red_red_red的博客
11-05 1709
6-6 尾插法创建单链表（C） （25 分） 本题要求实现两个函数，输入n个数据，采用尾插法创建单链表并打印。例如：如果输入4 ，再输入3 7 9 5，则应打印输出3 7 9 5。 链表结点结构定义： struct Node { //链表结点 int data; //数据 struct Node* link; //指向下一个结点的指针 }; 函数接口定...
尾插法建立单链表并输出
菜鸟的飞行日记
10-23 2855
题目描述 输入一个正整数序列，遇负数时停止，建立一个线性链表存储读入的数据，将各个元素按顺序输出。 样例输入 Copy 1 2 3 4 5 -1 样例输出 Copy 1 2 3 4 5 #include <iostream> #include<stdio.h> #include<stdlib.h> using namespace std; typedef struct Lnode{ int data; struct Lnode*next; }Lnode
C语言输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序建立单链表并输出。
氮气蜗牛的博客
05-19 1万+
/* 开发者：慢蜗牛 开发时间：2020.6.11 程序功能：逆序建立链表，顺序输出 */ #include<stdio.h> #include<malloc.h> #define LEN sizeof(struct once) struct once//建立结构 { int a; struct once* next; }; struct once* out()//建立头插法逆序建立链表 { int n = 0; struct once* p1, * p2; pr.
尾插法建立单链表，并输出链表
xinpx1457的博客
03-05 6740
#include <stdio.h> #include <stdlib.h> typedef struct LNode { int data ; struct LNode *next; } LNode,*LinkList; LinkList L;//定义全局变量L，可省略参数传递 LinkList insert()//尾插法建立单链表； { ...
C/C++笔试必备：链表反转与编程知识点解析
"C/C++笔试题目大全，涵盖链表反转、引用、指针、结构、联合、函数、变量、重载、多态、程序、类等核心知识点。" 在C/C++编程领域，这些知识点是构建复杂程序的基础。让我们逐一深入探讨： 1. 链表反转： - 链表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值