每日一题(15) - 如何知道两个单链表（可能有环）是否相交

最新推荐文章于 2024-04-13 16:57:01 发布
最新推荐文章于 2024-04-13 16:57:01 发布
阅读量1k 收藏 1
点赞数
分类专栏： 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/insistGoGo/article/details/9152427
版权
本文介绍了一种判断两个有环单链表是否相交的方法，通过定位链表中的环入口点并验证其是否存在于另一个链表中来实现。文章提供了详细的算法步骤及示例代码。

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

题目来自编程之美

题目：如何知道两个单链表（可能有环）是否相交

分析：根据两个链表是否有环来分别处理，具体参考单链表面试题

1、如果两个链表都没有环。可直接根据两个链表最后一个元素是否相等确定是否有环。

2、一个有环，一个没环。肯定不相交

3、两个都有环。（注，两个有环链表相交是指这个环属于两个链表共有）

这里重点求第三种情况：即判定两个都有环的链表是否相交。

思路：在链表A中找到环中一个结点，之后判断该结点是否在B中。此时该结点可以使用环中任意结点，为了方便，这里使用两个指针的碰撞点。

具体思路：在A链表上， 使用指针追赶的方法，找到两个指针碰撞点，之后判断碰撞点是否在B链表上。如果在，则相交 。

代码

struct ListNode
{
	int m_Data;
	ListNode* m_pNext;
};

/*思路:在A链表上，使用指针追赶的方法，找到两个指针碰撞点，之后判断碰撞点是否在B链表上。如果在，则相交 。*/
bool IsCrossing(ListNode* pFirstHead,ListNode* pSecHead)
{
	assert(pFirstHead != NULL && pSecHead);
	ListNode* pCurOfFirst = pFirstHead;
	ListNode* pCurOfSec = pSecHead;
	ListNode* pMeetNode = FindMeetNode(pCurOfFirst);//获得第一个链表的入口结点
	int nCountOfSec = GetNodeCountOfList(pSecHead);//获得第二个带环链表中元素个数
	//把第一个链表的入口点与第二个链表的每一个结点比较
	for (int i = 1;i <= nCountOfSec;i++)
	{
		if (pMeetNode == pCurOfSec)
		{
			return true;
		}
		pCurOfSec = pCurOfSec->m_pNext;
	}
	return false;
}

/*
思路：统计第一个结点到碰撞点之间结点个数 + 统计环中结点个数
1、先找到碰撞点
2、利用碰撞点，找到环入口点，同时统计第一个结点到碰撞点之间结点个数
3、利用碰撞点或者环入口点，在环中转圈，统计环中结点个数
*/
int GetNodeCountOfList(ListNode* pHead)
{
	assert(pHead != NULL);
	ListNode* pFast = pHead;
	ListNode* pSlow = pHead;
	ListNode* pEntry = pHead;
	int nCountOfBeforeEntry = 0; //统计第一个结点到碰撞点之间结点个数
	int nCountOfCycle = 1; //统计环中结点个数

	while (pFast->m_pNext && pFast->m_pNext->m_pNext)
	{
		pFast = pFast->m_pNext->m_pNext;
		pSlow = pSlow->m_pNext;
		if (pFast == pSlow)//找到碰撞点
		{
			//查找环的入口结点,并统计第一个结点到碰撞点之间结点个数
			while (pEntry != pSlow)
			{
				pEntry = pEntry->m_pNext;
				pSlow = pSlow->m_pNext;
				nCountOfBeforeEntry++;
			}
			//统计环中结点个数
			pSlow = pFast;
			pFast = pFast->m_pNext;
			while (pFast != pSlow)
			{
				pFast = pFast->m_pNext;
				nCountOfCycle++;
			}
			return nCountOfBeforeEntry + nCountOfCycle;
		}
	}
	return 0;
}

/*在快慢指针相遇处，使用两个指针分别从头结点和碰撞处开始走，相遇点就是环入口点*/
ListNode* FindMeetNode(ListNode* pHead)
{
	assert(pHead != NULL);
	ListNode* pFast = pHead;
	ListNode* pSlow = pHead;
	ListNode* pMeetNode = pHead;

	while (pFast->m_pNext && pFast->m_pNext->m_pNext)
	{
		pFast = pFast->m_pNext->m_pNext;
		pSlow = pSlow->m_pNext;
		if (pFast == pSlow)//找到碰撞点
		{
			return pFast;
		}
	}
	return NULL;
}

测试代码

#include <iostream>
#include <assert.h>
using namespace std;


struct ListNode
{
	int m_Data;
	ListNode* m_pNext;
};


/*
思路：统计第一个结点到碰撞点之间结点个数 + 统计环中结点个数
1、先找到碰撞点
2、利用碰撞点，找到环入口点，同时统计第一个结点到碰撞点之间结点个数
3、利用碰撞点或者环入口点，在环中转圈，统计环中结点个数
*/
int GetNodeCountOfList(ListNode* pHead)
{
	assert(pHead != NULL);
	ListNode* pFast = pHead;
	ListNode* pSlow = pHead;
	ListNode* pEntry = pHead;
	int nCountOfBeforeEntry = 0; //统计第一个结点到碰撞点之间结点个数
	int nCountOfCycle = 1; //统计环中结点个数


	while (pFast->m_pNext && pFast->m_pNext->m_pNext)
	{
		pFast = pFast->m_pNext->m_pNext;
		pSlow = pSlow->m_pNext;
		if (pFast == pSlow)//找到碰撞点
		{
			//查找环的入口结点,并统计第一个结点到碰撞点之间结点个数
			while (pEntry != pSlow)
			{
				pEntry = pEntry->m_pNext;
				pSlow = pSlow->m_pNext;
				nCountOfBeforeEntry++;
			}
			//统计环中结点个数
			pSlow = pFast;
			pFast = pFast->m_pNext;
			while (pFast != pSlow)
			{
				pFast = pFast->m_pNext;
				nCountOfCycle++;
			}
			return nCountOfBeforeEntry + nCountOfCycle;
		}
	}
	return 0;
}


/*在快慢指针相遇处，使用两个指针分别从头结点和碰撞处开始走，相遇点就是环入口点*/
ListNode* FindMeetNode(ListNode* pHead)
{
	assert(pHead != NULL);
	ListNode* pFast = pHead;
	ListNode* pSlow = pHead;
	ListNode* pMeetNode = pHead;


	while (pFast->m_pNext && pFast->m_pNext->m_pNext)
	{
		pFast = pFast->m_pNext->m_pNext;
		pSlow = pSlow->m_pNext;
		if (pFast == pSlow)//找到碰撞点
		{
			return pFast;
		}
	}
	return NULL;
}


/*思路:在A链表上，使用指针追赶的方法，找到两个指针碰撞点，之后判断碰撞点是否在B链表上。如果在，则相交 。*/
bool IsCrossing(ListNode* pFirstHead,ListNode* pSecHead)
{
	assert(pFirstHead != NULL && pSecHead);
	ListNode* pCurOfFirst = pFirstHead;
	ListNode* pCurOfSec = pSecHead;
	ListNode* pMeetNode = FindMeetNode(pCurOfFirst);//获得第一个链表的入口结点
	int nCountOfSec = GetNodeCountOfList(pSecHead);//获得第二个带环链表中元素个数
	//把第一个链表的入口点与第二个链表的每一个结点比较
	for (int i = 1;i <= nCountOfSec;i++)
	{
		if (pMeetNode == pCurOfSec)
		{
			return true;
		}
		pCurOfSec = pCurOfSec->m_pNext;
	}
	return false;
}


void CreateList(ListNode** pHead,int nLen)//头指针使用指针的指针
{
	assert(*pHead == NULL && nLen > 0);
	ListNode* pCur = NULL;
	ListNode* pNewNode = NULL;
	for (int i = 0;i < nLen;i++)
	{
		pNewNode = new ListNode;
		cin>>pNewNode->m_Data;
		pNewNode->m_pNext = NULL;


		if (*pHead == NULL)
		{
			*pHead = pNewNode;
			pCur = *pHead;
		}
		else
		{
			pCur->m_pNext = pNewNode;
			pCur = pNewNode;
		}
	}
}


/*让第一个链表的尾指针指向第二个链表的第三个元素
如果第二个链表没有第三个元素，则两个链表不相交,
如果第二个链表有第三个元素，则两个链表交点在环外*/
void CreateCrossingList1(ListNode* pFirstHead,ListNode* pSecHead)
{
	assert(pFirstHead != NULL && pSecHead);
	ListNode* pCurOfFirst = pFirstHead;
	ListNode* pCurOfSec = pSecHead;
	//寻找第一个链表最后一个结点
	while (pCurOfFirst->m_pNext)
	{
		pCurOfFirst = pCurOfFirst->m_pNext;
	}
	//第一个链表最后一个结点指向第二链表的第三个元素
	if (pCurOfSec->m_pNext && pCurOfSec->m_pNext->m_pNext)
	{
		pCurOfFirst->m_pNext = pCurOfSec->m_pNext->m_pNext;
	}	
}


/*让第一个链表pFirstHead的尾指针指向第二个链表pSecHead的第四个元素
如果第二个链表没有第四个元素，则两个链表不相交,
如果第二个链表有第四个元素，则两个链表交点在环内*/
void CreateCrossingList2(ListNode* pFirstHead,ListNode* pSecHead)
{
	assert(pFirstHead != NULL && pSecHead);
	ListNode* pCurOfFirst = pFirstHead;
	ListNode* pCurOfSec = pSecHead;
	//寻找第一个链表最后一个结点
	while (pCurOfFirst->m_pNext)
	{
		pCurOfFirst = pCurOfFirst->m_pNext;
	}
	//第一个链表最后一个结点指向第二链表的第三个元素
	if (pCurOfSec->m_pNext && pCurOfSec->m_pNext->m_pNext && pCurOfSec->m_pNext->m_pNext->m_pNext)
	{
		pCurOfFirst->m_pNext = pCurOfSec->m_pNext->m_pNext->m_pNext;
	}	
}


/*判断是不是环*/
bool IsCycle(ListNode* pHead)
{
	assert(pHead != NULL);
	ListNode* pFast = pHead;
	ListNode* pSlow = pHead;
	while (pFast->m_pNext && pFast->m_pNext->m_pNext)
	{
		pFast = pFast->m_pNext->m_pNext;
		pSlow = pSlow->m_pNext;
		if (pFast == pSlow)
		{
			return true;
		}
	}
	return false;
}


/*把链表最后一个结点指向第四个结点*/
void CreateCycle(ListNode* pHead)
{
	assert(pHead);
	ListNode* pLastNode = pHead;
	while (pLastNode->m_pNext)
	{
		pLastNode = pLastNode->m_pNext;
	}
	if (pHead->m_pNext && pHead->m_pNext->m_pNext && pHead->m_pNext->m_pNext->m_pNext)
	{
		pLastNode->m_pNext =  pHead->m_pNext->m_pNext->m_pNext;
	}
}


int main()
{
	int nLen = 0;
	bool bIsCrossing = false;


	//测试一，有交点且交点在环外
	ListNode* pHeadFirst = NULL;
	ListNode* pHeadSec = NULL;


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadFirst,nLen);
	CreateCycle(pHeadFirst);


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadSec,nLen);
	CreateCrossingList1(pHeadSec,pHeadFirst);//交点在环外


	if (IsCycle(pHeadFirst) && IsCycle(pHeadSec))
	{
		cout<<"两个链表均有环!"<<endl;
		bIsCrossing = IsCrossing(pHeadFirst,pHeadSec);
		if (bIsCrossing)
		{
			cout<<"相交!"<<endl;
		}
		else
		{
			cout<<"不相交!"<<endl;
		}
	}
	else
	{
		cout<<"两个链表不均有环!"<<endl;
	}




	//测试二，有交点且交点在环内
	ListNode* pHeadFirst1 = NULL;
	ListNode* pHeadSec1 = NULL;


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadFirst1,nLen);
	CreateCycle(pHeadFirst1);


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadSec1,nLen);
	CreateCrossingList2(pHeadSec1,pHeadFirst1); //交点在环内


	if (IsCycle(pHeadFirst1) && IsCycle(pHeadSec1))
	{
		cout<<"两个链表均有环!"<<endl;
		bIsCrossing = IsCrossing(pHeadFirst1,pHeadSec1);
		if (bIsCrossing)
		{
			cout<<"相交!"<<endl;
		}
		else
		{
			cout<<"不相交!"<<endl;
		}
	}
	else
	{
		cout<<"两个链表不均有环!"<<endl;
	}


	//测试三，均有环，但是无交点
	ListNode* pHeadFirst2 = NULL;
	ListNode* pHeadSec2 = NULL;


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadFirst2,nLen);
	CreateCycle(pHeadFirst2);


	//创建有环链表
	cout<<"please input node num: ";
	cin >> nLen;
	CreateList(&pHeadSec2,nLen);
	CreateCycle(pHeadSec2);


	if (IsCycle(pHeadFirst2) && IsCycle(pHeadSec2))
	{
		cout<<"两个链表均有环!"<<endl;
		bIsCrossing = IsCrossing(pHeadFirst2,pHeadSec2);
		if (bIsCrossing)
		{
			cout<<"相交!"<<endl;
		}
		else
		{
			cout<<"不相交!"<<endl;
		}
	}
	else
	{
		cout<<"两个链表不均有环!"<<endl;
	}


	system("pause");
	return 1;
}

每日一题--判断两个链表相交
Mr Liu的博客
07-15 261
今天这道是面试中的高频题，有关链表和树的操作一直都是面试官比较喜欢考的，因为链表和树的操作涉及到指针的使用，面试官可以通过算法题的形式短时间内考察一个人对指针的熟练程度。话不多说，先来看题。 题目描述 　　判断两个单链表是否相交 ，并返回第一个相交的元素。 思路 　　可以想到，如果两个链表相交，那么它肯定是尾部相连，首部分开，就像朝左侧卧的“Y”形。因此，能够想到两种思路，一种是从后往前遍历链表，直到两个链表的某个结点元素值不相等，那这个结点的前一个结点就是第一个相交的结点。另外一种思路就是从前往后遍历，首
每日一题---OJ题: 环形链表 II
qq_74336191的博客
04-13 962
当slow指针走到中间的时候,fast指针开始进环链表头->入口点: L当slow指针开始进环的时候,fast指针在环中可能已经走了n圈了此时,fast指针和slow指针都在环里面,slow指针进环以后开始追击。在上一章中，我们知道，当。
判断两个单链表是否相交（链表中可能有环的情况下）
一颗闪亮的星星
02-18 2854
原文链接：http://www.cppblog.com/zengwei0771/articles/172700.html 题目描述：判断两个单链表是否相交，如果相交，给出相交的第一个点（链表中可能有环的情况下） 这里是①判断单链表是否有环，并求出环的入口点；②判断两个链表是否相交（链表中无环），并求出相交节点 的文章  http://www.cppblog.com/humanchao/a
两个单链表是否相交（考虑有环和无环）
zhonghua18517的专栏
06-05 953
步骤如下： (1)判断两个单链表中是否有环，如果
两个单链表(可能有环)是否相交，若相交则返回第一个相交点
LeeWei
10-27 314
/** * Created by lxw, liwei4939@126.com on 2017/10/27. * 两个单链表是否相交，若相交则返回第一个相交点(单链表可能有环) */ public class IntersectNode { public class Node{ public int value; public Node next;
判断两个链表是否相交
DSIslander的专栏
11-23 740
判断两个链表是否相交   2012-01-09 10:37:03|  分类： 默认分类 |  标签： |字号大中小 订阅 给出两个单向链表的头指针，判断这两个链表是否相交，如果相交给出相交的第一个结点 一、两个链表均不含有环 链表相交如下图    方法一：直接法    直接判断第一个链表的每个结点是否在第二个链表中，时间复杂度为O(len1*len2)，耗时很大 方
判断两个可能有环的链表是否有交点
weixin_43578004的博客
08-07 532
判断两个可能有环的链表是否有交点两个单链表相交的一系列问题首先需要判断单链表是否有环hashSet（很简单，不多说，空间复杂度O(n)）快慢指针接下来就需要解决有无交点的问题：两个无环链表是否有交点：两个有环链表是否有交点（***三种拓扑结构***）完整代码（java） 最近准备面试的时候碰到的一道题，记录一下…… 【问题】：单链表可能有环， 也可能无环。 给定两个 单链表的头节点 head1和head2， 这两个链表可能相交， 也可能 不相交。 请实现一个函数， 如果两个链表相交， 请返回相交的 第一个节
LeetCode每日一刷 --- 手撕单链表习题（2）
bit_zyx的博客
03-26 2971
目录 1、链表的回文结构 2、相交链表 3、复制带随机指针的链表 1、链表的回文结构 链接直达： 链表的回文结构 题目： 思路： 找中间节点再逆置 2、相交链表 3、复制带随机指针的链表 ...
每日一题---OJ题: 环形链表
qq_74336191的博客
04-13 733
思路分析： slow指针走1步,fast指针走2步,一定可以追上吗?会不会追不上?当slow指针走到中间的时候,fast指针开始进环当slow指针开始进环的时候,fast指针在环中可能已经走了n圈了因为slow指针和fast指针都在环里面,slow指针进环以后开始追击。假设此时fast指针和slow指针之间的距离为N , 每追击一次,它们之间的距离缩小一步。追击过程中, fast 和 slow 之间的距离变化第0次: N第1次: N-1第2次: N-2第3次: N-3。
2021-11-05 Leetcood 160 每日一题
qq_44745905的博客
11-05 1261
@R星校长 已知两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 杰哥我用白话翻译过来： 链表A和链表B相交于C节点，我们返回C节点的地址，如果两个链表之间没有交点，程序返回null 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。 杰哥我用白话翻译过来： 不能删除节点、添加节点或是改变节点内的数据。 本题当中有多种解法，实现算法的时候，我.
面试题 02.07. 链表相交（leetcode每日打卡）
m0_60264772的博客
11-16 986
面试题 02.07. 链表相交 给你两个单链表的头节点headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据保证整个链式 注意，函数返回结果后，链表必须保持其原始结构。 示例 1： 结构中不存在环。 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 ...
判断两个单向链表是否存在环
渡辺麻友
03-30 1145
今天Mayuyu来带领你们讨论如下三个问题：    （1）如何判断一个单链表是否存在环 ？  （2）如果存在环，如何找到环的入口点？  （3）两个链表中有环时，如何判断相交？     问题一   我们设置两个指针，分别是fast和slow，初始都指向这个单向链表的表头，fast每次走两步，而slow每次走一步， 所以，我们知道如果有环，那么fast先进入环，slow后进入环，在
判断两个单链表是否相交（有环、无环两种）
weixin_38168547的博客
07-12 1075
题目描述： 　　给定两个单链表的头节点head1和head2，如何判断两个链表是否相交？相交的话返回true，不想交的话返回false。 　　给定两个链表的头结点head1和head2。请返回一个bool值代表它们是否相交。 　　链表中节点的类型设置如下： class ListNode { int val; ListNode next = null; ...
三电平SVPWM模型的Matlab仿真及其在逆变器性能优化中的应用
05-01
内容概要：本文详细介绍了三电平SVPWM模型在Matlab中的搭建与研究，重点探讨了三电平逆变器的工作原理、性能特点以及参数优化方法。文中不仅解释了三电平逆变器相较于传统两电平逆变器的优势，如更高的电压分辨率和更低的谐波失真，还深入讨论了SVPWM控制策略的具体实现步骤，包括扇区划分、中性点电压平衡、死区时间和波形生成等关键环节。此外，文章还强调了仿真与实际应用之间的差异，指出仿真只是调试的起点而非终点。 适合人群：从事电力电子、自动化控制领域的研究人员和技术人员，尤其是对逆变器建模和仿真相关工作的从业者。 使用场景及目标：适用于需要深入了解三电平逆变器特性和优化控制策略的研究项目，旨在帮助读者掌握基于Matlab的三电平SVPWM模型构建技巧，从而更好地进行逆变器性能评估和改进。 其他说明：文章提供了大量实用的Matlab代码片段，便于读者理解和实践。同时提醒读者关注仿真与现实应用间的细微差别，确保理论成果能够顺利转化为实际效益。
spring-boot-2.3.9.RELEASE.jar中文文档.zip
05-01
# 压缩文件中包含： 中文文档 jar包下载地址 Maven依赖 Gradle依赖 源代码下载地址 # 本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 # 特殊说明： ·本文档为人性化翻译，精心制作，请放心使用。 ·只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； ·不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 # 温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
水利规范-7p倒虹吸工程及渠道防渗衬砌设计图集.zip
最新发布
05-01
水利规范-7p倒虹吸工程及渠道防渗衬砌设计图集.zip
JAVAWeb外文文献毕业设计样本.doc
05-01
JAVAWeb外文文献毕业设计样本.doc
scratch少儿编程逻辑思维游戏源码-我的世界冒险通过 V5.zip
05-01
scratch少儿编程逻辑思维游戏源码-我的世界冒险通过 V5.zip
scratch少儿编程逻辑思维游戏源码-星之卡比 动画.zip
05-01
scratch少儿编程逻辑思维游戏源码-星之卡比 动画.zip
用C语言写一个程序判断两个单链表是否相交
11-20
在C语言中，我们可以使用双指针法来编写一个程序判断两个单链表是否相交。这里是一个简单的示例： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 typedef struct ListNode { int val; struct ListNode* next; } ListNode; // 创建新节点 ListNode* createNode(int val) { ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); if (!newNode) { printf("Memory allocation failed.\n"); return NULL; } newNode->val = val; newNode->next = NULL; return newNode; } // 判断两个链表是否有交叉点 int isListIntersect(ListNode* listA, ListNode* listB) { ListNode* p1 = listA; // 指针p1遍历listA ListNode* p2 = listB; // 指针p2遍历listB // 遍历列表直到有一个到达末尾 while (p1 != NULL && p2 != NULL) { if (p1 == p2) { // 如果找到相同的节点，则有交点 return 1; } p1 = p1->next ? p1->next : listB; // 如果p1到了末尾，从头开始遍历listB p2 = p2->next ? p2->next : listA; // 同理，如果p2到了末尾，从头开始遍历listA } return 0; // 没有找到交点，返回0 } // 测试函数 void testIntersection() { ListNode* listA = createNode(1); listA->next = createNode(2); listA->next->next = createNode(4); listB = createNode(3); listB->next = createNode(4); // 两链表在这里相交 int result = isListIntersect(listA, listB); if (result) printf("The two lists intersect.\n"); else printf("The two lists do not intersect.\n"); } int main() { testIntersection(); return 0; } ``` 这个程序首先创建两个单链表，然后使用`isListIntersect`函数检查它们是否有交点。如果有交点，该函数会返回1，否则返回0。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值