求单链表的最大值与原地逆转

最新推荐文章于 2022-11-02 17:17:59 发布
最新推荐文章于 2022-11-02 17:17:59 发布
阅读量8.4k 收藏 22
点赞数 7
分类专栏： 数据结构与算法 文章标签： 链表 指针 c++ 线性表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangbowj123/article/details/61923422
版权

数据结构链表一章已学习完毕，因此编了一个程序用以实现链式表的构建，插入，查找，求最大值，以及原地逆转。

除了求最大值与原地逆转之外都是常规操作，不再赘述，着重分析最大值与逆转的算法。

一、最大值的求解：通过max函数实现，定义结构体指针p指向l的首元节点，max初值为p->data，通过if判断是否有更大的数，将更大的数赋值给max，同时p指向下一个节点，由此求出最大的数。代码如下：

void max(LinkList l,int n)//求最大值 
{
	 int max;
	 LinkList p;
	 p=l->next;
	 max=p->data;
	 for(int i=0;i<n;i++)
	 {
	  
	  if(max<p->data)
	   max=p->data;
	  else max=max;
	  p=p->next;
	 }
	cout<<"max="<<max<<endl;
}

二、将链表原地逆转：方法其实很简单，定义两个指针变量p，q分别指向l的首元节点与之后的节点，然后令p成为q的后继，之后令q指向下一个节点，p的值变为q，一直重复直到q变为NULL，即到达了尾节点，此时令首元节点变为p，将尾节点制空即可。代码如下： 

void resver(LinkList &l,int n)
{
	LinkList p,q,temp=NULL;//temp为中间变量 
	
	p=l->next;//p指向首元节点 
	
	q=l->next->next;
	if(p==NULL||q==NULL)
	{
		cout<<"无法逆转"<<endl;//空链表或者只有一个数据时无法逆转 
		return ;
	}
	
	while(q!=NULL)
	{
		temp=q->next;
		q->next=p;//令p变为q的后继 
		p=q;//p往后移动 
		q=temp;//q指向下一个节点 
	}
	l->next->next=NULL;//设置尾节点为空 
	l->next=p;//设置首元节点为p
	cout<<"链表逆转后的结果是：" ;
	while(p!=NULL)
		{
			cout<<p->data<<" ";
			p=p->next;
		}
		cout<<endl;
	
		
	
}

三、整个链表操作实现如下： 

#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;		//Status 是函数返回值类型，其值是函数结果状态代码。
typedef int ElemType;	 //ElemType 为可定义的数据类型，此设为int类型

typedef struct LNode
{
	ElemType data;							//结点的数据域
	struct LNode *next;						//结点的指针域
}LNode,*LinkList;							//LinkList为指向结构体LNode的指针类型


Status InitList_L(LinkList &L){				//算法2.5 单链表的初始化
	//构造一个空的单链表L
	L=new LNode;							//生成新结点作为头结点，用头指针L指向头结点
	L->next=NULL;							//头结点的指针域置空
	return OK;
}

Status GetElem_L(LinkList L,int i,ElemType &e){		//算法2.6 按序号查找
	//在带头结点的单链表L中查找第i个元素
	int j;
	LNode *p;
	p=L->next;j=1;							//初始化，p指向第一个结点，j为计数器
	while(j<i&&p){							//顺链域向后扫描，直到p指向第i个元素或p为空
		p=p->next;++j;
	}
	if(!p || j>i)	return ERROR;			//第i个元素不存在
	e=p->data;								//取第i个元素
	return OK;
}											//GetElem_L

LNode *LocateElem_L(LinkList L,ElemType e){			//算法2.7 按值查找
	//在带头结点的单链表L中查找值为e的元素
	LNode *p;
	p=L->next;
	while(p&&p->data!=e)
		p=p->next;							//寻找满足条件的结点
	return p;								//返回L中的值为e的数据元素的位置，查找失败返回NULL
}											//LocateElem_L

Status ListInsert_L(LinkList &L,int i,ElemType &e){		//算法2.8 单链表的插入
	//在带头结点的单链表L中第i个位置之前插入元素e
	int j;
	LNode *p,*s;
	p=L;j=0;
	while(p && j<i-1){p=p->next;++j;}		//寻找第i-1个结点
	if(!p||j>i-1)	return ERROR;			//i大于表长+1或者小于1
	s=new LNode;							//生成新结点s
	s->data=e;								//将结点s的数据域置为e
	s->next=p->next;						//将结点s插入L中
	p->next=s;
	return OK;
}											//ListInsert_L

Status ListDelete_L(LinkList &L,int i,ElemType &e){		//算法2.9 单链表的删除
	//在带头结点的单链表L中，删除第i个位置，并由e返回值
	LNode *p,*q;
	int j;
	p=L;j=0;
	while(p->next && j<i-1){p=p->next;++j;}		//寻找第i-1个结点
	if(!(p->next) || j>i-1)		return ERROR;	//i大于表长+1或者小于1
	q=p->next;									//临时保存被删结点的地址以备释放
	p->next=q->next;							//改变删除结点前驱结点的指针域
	e=q->data;									//保存删除结点的数据域
	delete q;									//释放删除结点的空间
	return OK;
}												//ListDelete_L

void CreateList_F(LinkList &L,int n){				//算法2.10 前插法创建单链表
	//逆位序输入n个元素的值，建立到头结点的单链表L
	LNode *p;
	L=new LNode;
	L->next=NULL;								//先建立一个带头结点的空链表
	cout<<"请输入 "<<n<<" 个数:\n";
	for(int i=n;i>0;--i){
		p=new LNode;							//生成新结点
		cin>>p->data;							//输入元素值
		p->next=L->next;L->next=p;				//插入到表头
	}
}												//CreateList_F

void CreateList_L(LinkList &L,int n){				//算法2.11 后插法创建单链表
	//正位序输入n个元素的值，建立到头结点的单链表L
	LNode *r,*p;
	L=new LNode;
	L->next=NULL;								//先建立一个带头结点的空链表
	r=L;										//尾指针r指向头结点
	cout<<"请输入 "<<n<<" 个数:\n";
	for(int i=0;i<n;i++){
		p=new LNode;							//生成新结点
		cin>>p->data;							//输入元素值
		p->next=NULL;r->next=p;					//插入到表尾
		r=p;									//r指向新的尾结点
	}
}												//CreateList_L
void max(LinkList l,int n)//求最大值 
{
	 int max;
	 LinkList p;
	 p=l->next;
	 max=p->data;
	 for(int i=0;i<n;i++)
	 {
	  
	  if(max<p->data)
	   max=p->data;
	  else max=max;
	  p=p->next;
	 }
	cout<<"max="<<max<<endl;
}
void resver(LinkList &l,int n)
{
	LinkList p,q,temp=NULL;//temp为中间变量 
	
	p=l->next;//p指向首元节点 
	
	q=l->next->next;
	if(p==NULL||q==NULL)
	{
		cout<<"无法逆转"<<endl;//空链表或者只有一个数据时无法逆转 
		return ;
	}
	
	while(q!=NULL)
	{
		temp=q->next;
		q->next=p;//令p变为q的后继 
		p=q;//p往后移动 
		q=temp;//q指向下一个节点 
	}
	l->next->next=NULL;//设置尾节点为空 
	l->next=p;//设置首元节点为p
	cout<<"链表逆转后的结果是：" ;
	while(p!=NULL)
		{
			cout<<p->data<<" ";
			p=p->next;
		}
		cout<<endl;
	
		
	
}
int main()
{
	int res,a,b,choose,n;
	LNode *L,*p;
	cout<<"1. 建立链表\n";
	cout<<"2. 输入数据\n";
	cout<<"3. 按位置查找\n";
	cout<<"4. 按值查找\n";
	cout<<"5. 链表的插入\n";
	cout<<"6. 链表的删除\n";
	cout<<"7. 输出数据\n";
	cout<<"8. 输出最大值\n";
	cout<<"9. 将原链表逆转并输出结果"<<endl;
	cout<<"0. 退出\n\n";
	
	choose=-1;
	while(choose!=0)
	{
		cout<<"请选择:";
		cin>>choose;
		switch(choose)
		{
		case 1:					//建立一个单链表
			if(InitList_L(L))
				cout<<"成功建立链表!\n\n";
			break;
		case 2:					//使用后插法创建单链表
			cout<<"输入元素个数:";
			cin>>n;
			cout<<endl;
			CreateList_L(L,n);
			cout<<"成功创建链表!\n\n";
			break;
		case 3:					//单链表的按序号查找
			cout<<"请输入一个位置用来查找:";
			cin>>a;
			if(GetElem_L(L,a,res))
				cout<<"查找成功!第"<<a<<"个数是："<<res<<"\n\n";
			else
				cout<<"查找失败\n\n";	
			break;
		case 4:					//单链表的按值查找
			cout<<"请输入一个数值用来查找:";
			cin>>b;
			if(LocateElem_L(L,b)!=NULL)
				cout<<"查找成功\n\n";
			else
				cout<<"查找失败! "<<b<<" 没有找到\n\n";
			break;
		case 5:					//单链表的插入
			cout<<"请输入两个数分别代表插入的位置和数值:";
			cin>>a>>b;
			if(ListInsert_L(L,a,b))
   				cout<<"成功将"<<b<<"插在第"<<a<<"个位置\n\n";
			else
				cout<<"插入失败!\n\n";
			break;
		case 6:					//单链表的删除
			cout<<"请输入一个位置用来删除:";
			cin>>a;
			if(ListDelete_L(L,a,res))
				cout<<"删除成功!被删除的数是："<<res<<"\n\n";
			else
				cout<<"删除失败!\n\n";	
			break;
		case 7:					//单链表的输出
			cout<<"现在链表里的数分别是:\n";
			p=L->next;
			while(p)
			{
				cout<<p->data<<" ";
				p=p->next;
			}
			cout<<endl;
			break;
		case 8:
			max(L,n);
			break;
		case 9:
			resver(L,n);
			break;
			
		}
	}
	return 0;
}


wangbowj123
关注
  • 7
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单链表的创建于逆转
06-29
经典单链表的创建与单链表项的逆转，C++代码实现
6-6 递归求单链表最大值
Ida_shi的博客
05-19 3375
本题要求实现一个函数，返回不带头结点的单链表中最大元素的地址。 函数接口定义： LinkList MaxP( LinkList L); L是不带头结点的单链表的头指针，函数MaxP返回表中最大元素的地址。如果单链表为空，返回空指针。 其中LinkList结构定义如下： typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; 裁判测试程序样例： #include <stdio.h> #incl
Chapter202单链表
qq_65394887的博客
11-02 387
内容来自: 数据结构教程: Java语言描述/李春葆,李筱驰主编.
【数据结构连载一线性表】【单链表】python
hbk5241的博客
05-07 208
# -*- coding: UTF-8 -*- """ 线性表之链式存储结构 基本操作: 初始化 __init__ 线性表空判断 empty 清空线性表 clear 获取元素 get 是否存在数据 exist 插入操作 insert 删除操作 delete 线性表的长度 length 扩展操作 遍历链表 show
查找链表中的最大值
m0_53354306的博客
11-02 5481
描述 利用单链表表示一个整数序列，通过一趟遍历在单链表中确定值最大的结点。 输入 多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。 输出 对于每组数据分别输出一行，输出每个链表的最大值。 输入样例 1 5 2 1 3 5 4 6 2 3 10 4 5 1 4 -1 -2 -3 -4 0 输出样例 1 5 10 -1 #include<iostream> #include<string...
求单链表最大值
posion__02的博客
04-18 2457
数据结构复习总结
weixin_51443397的博客
12-26 787
数据结构树和二叉树 树和二叉树 1.前中后序遍历二叉树 void PreOrder(BiNode *root) { if(root!=NULL) { cout<<root->data; PreOrder(root->lchild); PreOrder(root->rchild); } } void InOrder(BiNode *root) { if(root!=NULL) {
数据结构——返回带头结点的单链表L的逆转链表
＃两个西柚
07-21 1万+
代码填空： 下列代码的功能是返回带头结点的单链表L的逆转链表 List Reverse( List L ) { Position Old_head, New_head, Temp; New_head = NULL; Old_head = L->Next; while ( Old_head ) { Temp = Old_head->Next; ______________________________;
单链表逆转
08-01
使用C++描述的单链表处理程序源代码，可以实现单链表的逆转等操作。CodeBlocks下调试通过。
java 实现单链表逆转详解及实例代码
08-31
主要介绍了java 实现单链表逆转实例代码的相关资料,需要的朋友可以参考下
单链表逆转操作
04-28
单链表逆转操作，在笔试中经常可见 1实现整体逆转 2.实现相邻元素逆转
单链表的逆转求和
03-14
单链表的逆转求和，根据输入，完成单链表的建立操作，然后实现单链表的逆转，输出逆转之后各几点的元素值，最后输出所有元素之和。
python——三道贪心算法例题
热门推荐
学渣的博客
10-24 1万+
1.找零钱问题：假设只有 1 分、 2 分、五分、 1 角、二角、 五角、 1元的硬币。在超市结账 时，如果 需要找零钱， 收银员希望将最少的硬币数找给顾客。那么，给定 需要找的零钱数目，如何求得最少的硬币数呢？2.求最大子数组之和问题：给定一个整数数组（数组元素有负有正），求其连续子数组之和的最大值。3.汽车加油站问题
关于快速寻找素数的方法
学渣的博客
02-21 1万+
利用素数筛选法进行素数的快速查找。 原理很简单，素数一定是奇数，素数的倍数一定不是素数。 思路如下： 预定义N表示10000，即表示查找10000以内的素数，首先定义数组prime[]对N以内的数进行标记，奇数存为1，偶数存为0，最终实现结果为素数的prime值为1，因此将prime[2]赋值为1（2是素数）。之后利用for循环，对N以内的奇数进行遍历（注意for循环的条件控制），for里用if判断是否为素数（奇数），若是，执行内部嵌套的for循环判断该奇数是否为素数，若是则标记为1，若不是则prime置为
关于线性表的线性表的实现(顺序结构)
学渣的博客
03-01 3885
学习了数据结构后对线性表有了更好的了解，所谓线性表有两种实现方法，一种是用顺序结构，一种是用链式结构。具体说来就是用动态数组与链表的方式来实现。 这便是数据结构的两种储存方式，顺序存储结构与链式存储结构，同时也是数据结构研究的存储结构的具体体现，因此线性表的实现对于初步学习数据结构的我们有着重要的意义。 这篇博客用的是动态数组实现线性表。 利用了c++里面的关键词new  进行内存动态分配
c语言利用单链表原来的节点空间逆转一个单链表
最新发布
06-12
可以通过改变单链表节点的 next 指针的指向来实现单链表的逆转。具体实现方式如下： ```c void reverseLinkedList(Node* head) { Node *prev, *cur, *next; prev = NULL; cur = head; while (cur != NULL) { next = cur->next; // 先保存当前节点的下一个节点 cur->next = prev; // 当前节点的 next 指针指向前一个节点 prev = cur; // 更新前一个节点 cur = next; // 更新当前节点 } } ``` 在上述实现中，我们使用了三个指针：prev、cur 和 next。prev 指向当前节点的前一个节点，cur 指向当前节点，next 指向当前节点的下一个节点。每次循环先保存当前节点的下一个节点，然后将当前节点的 next 指针指向前一个节点，最后更新 prev、cur 和 next 的值。循环终止后，prev 指针指向原来链表的最后一个节点，即逆转后链表的头节点。因此，可以将原来链表的头节点改为 prev，实现单链表的逆转。 需要注意的是，上述实现方式只是改变了每个节点的 next 指针的指向，并没有改变节点本身的位置。因此，这种逆转方式利用了原来链表节点的空间，不需要额外的空间开销。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wangbowj123

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值