判断链表有没有环(要求用两种方法) [问题点数:20分,结帖人daring_t]

一键查看最优答案

确认一键查看最优答案?
本功能为VIP专享,开通VIP获取答案速率将提升10倍哦!
Bbs1
本版专家分:0
结帖率 96.67%
Bbs2
本版专家分:347
判断链表是否有并找到的入口等问题
<em>判断</em>单<em>链表</em>是否有<em>环</em>并找到<em>环</em>的入口等问题 假设一个单<em>链表</em>有<em>环</em>,他就是下面的这种情况: 我们有下面几个问题: 1.给一个单<em>链表</em>,<em>判断</em>其中是否有<em>环</em>的存在; 2.如果存在<em>环</em>,找出<em>环</em>的入口点; 3.如果存在<em>环</em>,求出<em>环</em>上节点的个数; 4.如果存在<em>环</em>,求出<em>链表</em>的长度; 对于这些问题有一种<em>方法</em>就是...
判断链表是否有,找到入节点--python实现
用快慢指针的<em>方法</em>。时间复杂度O(n),空间复杂度O(1)。 设置p1为慢指针,p2为快指针,两者初始时都指向<em>链表</em>的头结点 ,慢指针p1每次前进1步,快指针p2每次前进2步。如果<em>链表</em>存在<em>环</em>,则快指针p2肯定先进入<em>环</em>,慢指针p1后进入<em>环</em>,两个指针必定会相遇。如果不存在<em>环</em>,则快指针会先行到达<em>链表</em>的尾部变为None。 class LNode: def __init__(self, val): ...
【算法】如何判断链表
如何<em>判断</em>单<em>链表</em>是否存在<em>环</em> 有一个单向<em>链表</em>,<em>链表</em>当中有可能出现“<em>环</em>”,就像题图这样。如何用程序<em>判断</em>出这个<em>链表</em>是有<em>环</em><em>链表</em>? 不允许修改<em>链表</em>结构。 时间复杂度O(n),空间复杂度O(1)。 <em>方法</em>一、穷举遍历<em>方法</em>一:首先从头节点开始,依次遍历单<em>链表</em>的每一个节点。每遍历到一个新节点,就从头节点重新遍历新节点之前的所有节点,用新节点ID和此节点之前所有节点ID依次作比较。如果发现新
如何判断一个单链表是否有以及入口
这是一个在我们学习数据结构的时候经常会遇到的问题,今天给大家带来这个问题的几种解法。 <em>方法</em>一 最容易想到的办法就是遍历单<em>链表</em>,如果单<em>链表</em>有<em>环</em>的话那么会进入死循<em>环</em>,但是我们不知道单<em>链表</em>的长度,所以如果单<em>链表</em>长度很长,我们一直向下遍历,也无法分辨出是单<em>链表</em>还没遍历完还是进入了死循<em>环</em>。 所以这种解法不靠谱。 <em>方法</em>二 我们可以在遍历单<em>链表</em>中的每个元素的时候,每遍历一个新的节点,就从头再开...
图解Java数据结构之链表
本篇文章介绍数据结构中的<em>环</em>形<em>链表</em>。 介绍 <em>环</em>形<em>链表</em>,类似于单<em>链表</em>,也是一种链式存储结构,<em>环</em>形<em>链表</em>由单<em>链表</em>演化过来。单<em>链表</em>的最后一个结点的链域指向NULL,而<em>环</em>形<em>链表</em>的建立,不要专门的头结点,让最后一个结点的链域指向<em>链表</em>结点。 简单点说<em>链表</em>首位相连,组成<em>环</em>状数据结构。如下图结构: 而在<em>环</em>形<em>链表</em>中,最为著名的即是约瑟夫<em>环</em>问题。 约瑟夫<em>环</em>问题 问题介绍: 设编号为1、2、3、… 、n的n个人围坐一圈,...
每天一道LeetCode-----判断链表是否有,如果有,找到的入口位置
Linked List Cycle原题链接Linked List Cycle<em>判断</em>一个<em>链表</em>是否有<em>环</em>,空间复杂度是O(1)如果不考虑空间复杂度,可以使用一个map记录走过的节点,当遇到第一个在map中存在的节点时,就说明回到了出发点,即<em>链表</em>有<em>环</em>,同时也找到了<em>环</em>的入口。不适用额外内存空间的技巧是使用快慢指针,即采用两个指针walker和runner,walker每次移动一步而runner每次移动两步。当w
Java算法:判断链表是否有
README 单<em>链表</em>是否有<em>环</em>,这是一个挺有意思的问题,这里我并没有提出新的解法,而是解释了现有的解法,帮助新人和自己理解。 题目描述 <em>判断</em>一个单<em>链表</em>是否有<em>环</em>,如果有,返回第一个<em>环</em>内的节点的引用,如果没有<em>环</em>,返回nuill。 编程依据 1. 两个指针从<em>链表</em>头部同时出发,一个每次前进一步,另一个每次前进两步,如果有<em>环</em>,为什么它们一定会相遇? 假设pOne前进...
笔试题:如何判断链表是否存在
给定一个单<em>链表</em>,只给出头指针h:1、如何<em>判断</em>是否存在<em>环</em>?2、如何知道<em>环</em>的长度?3、如何找出<em>环</em>的连接点在哪里?4、带<em>环</em><em>链表</em>的长度是多少? 解法:1、对于问题1,使用追赶的<em>方法</em>,设定两个指针slow、fast,从头指针开始,每次分别前进1步、2步。如存在<em>环</em>,则两者相遇;如不存在<em>环</em>,fast遇到NULL退出。2、对于问题2,记录下问题1的碰撞点p,slow、fast从该点
判断链表是否有
#include using namespace std; class List { public: List(int num) { this->num = num; } int num; List* next; }; //创建<em>链表</em> List* createList(int count) { if(count == 0 ) return N
如何判断链表及正确性证明
双指针<em>判断</em>单<em>链表</em>是否有<em>环</em>的正确性证明 ​ 首先介绍一下这个问题。给你一个单<em>链表</em>,需要找到一个<em>方法</em>进行<em>判断</em>是否有<em>环</em>的存在。这篇文章主要证明一下,为什么存在<em>环</em>的情况下两个指针(slow和fast指针)就一定会相遇。 <em>判断</em>单<em>链表</em>是否有<em>环</em> ​ 使用两个slow, fast指针从头开始扫描<em>链表</em>。指针slow 每次走1步,指针fast每次走2步。如果存在<em>环</em>,则指针slow、fast会相遇;如...
LeetCode141---判断是否是链表
问:给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。进阶:你能否不使用额外空间解决此题?这道题的思路有两种,一种是以前在找<em>链表</em>中点时用过的快慢指针,如果有<em>环</em>的话,快指针总会和慢指针相遇,一种是用递归,里面很巧妙的让每个节点的next指向自己,当一遍遍历结束之后,我们会遇到自己指向自己的节点,那说明有<em>环</em>。快慢指针的代码:public class Solution { public boolean hasC...
LeetCode-链表(java实现)
题目如下 ​​​​本篇文章讨论的都是单<em>链表</em> <em>环</em>形<em>链表</em>就是循<em>环</em><em>链表</em>的意思。即<em>链表</em>的尾节点不是null,而是重新指向<em>链表</em>的其他节点。 <em>判断</em>一个单<em>链表</em>是否是循<em>环</em><em>链表</em>,可以采用快慢指针,追击相遇的方式来实现。算法的原理可以形象的比喻成“龟兔赛跑”。兔子的速度是乌龟的两倍,它们在一个<em>环</em>形的跑道上面赛跑。经过一段时间之后,兔子必定会超过乌龟一圈,然后相遇。我们循<em>环</em>一个单<em>链表</em>,如果这个单<em>链表</em>是循<em>环</em><em>链表</em>,快指...
8道链表常考题-链表
已知<em>链表</em>中可能存在<em>环</em>,若有<em>环</em>返回<em>环</em>起始节点,否则返回NULL。 使用set求<em>环</em>起始节点 使用快慢指针
判断链表是否有(Java实现)
给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>的几种<em>方法</em> 今天刷LeetCode刷到一道这样的题,详情参见(https://leetcode-cn.com/problems/linked-list-cycle/) ADT: class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = n...
给定一个链表判断链表中是否有
给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。 为了表示给定<em>链表</em>中的<em>环</em>,我们使用整数 pos 来表示<em>链表</em>尾连接到<em>链表</em>中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该<em>链表</em>中没有<em>环</em>。 解题思路: 用快慢指针进行遍历,如果相等则返回true,否则返回false。但是此节点不一定为<em>环</em>的入口点,只能证明存在<em>环</em>而已。 /** * Definition for singly-linked list. *...
链表——链表
<em>环</em>形<em>链表</em>也叫循<em>环</em>单<em>链表</em>,操作原理和单<em>链表</em>差不多,只是最后一个节点不在指向空(null)而是头(head);/* * 循<em>环</em>单<em>链表</em> */ class TestCLink{ class Entry{//节点类 int data; Entry next; public Entry() { this.data = 1;
判断链表中是否有,找到的入口节点
<em>判断</em>单<em>链表</em>中是否有<em>环</em>,找到<em>环</em>的入口节点声明 文章可以随意转载,但请注明出处。 文中有一些地方引用了其他文章,但都已标明出处。如有侵犯,可立即删除。 文中有些地方并无冒犯之意,希望提及的博客作者理解。没有你们的帮助,对这个问题毫无头绪。 由于CSDN博客系统的内部错误,所有的公式后面都有一条恼人的竖线,实属无奈。 欢迎评论。 文章梗概 本文通过对现有资料的收集和整理,给出了一种相对简单的严格证明的
高并发下线程安全的单例模式(最全最经典)
原文:目录(?)[+]在所有的设计模式中,单例模式是我们在项目开发中最为常见的设计模式之一,而单例模式有很多种实现方式,你是否都了解呢?高并发下如何保证单例模式的线程安全性呢?如何保证序列化后的单例对象在反序列化后任然是单例的呢?这些问题在看了本文之后都会一一的告诉你答案,赶快来阅读吧!什么是单例模式?在文章开始之前我们还是有必要介绍一下什么是单例模式。单例模式是为确保一个类只有一个实例,并为整个...
java面试代码题
1.阅读 Shape 和 Circle 两个类的定义。在序列化一个 Circle 的对象 circle 到 文件时,下面哪个字段会被保存到文件中? 文件时,下面哪个字段会被保存到文件中? A. name B. radius C. color D. type 答案:B 2. ArrayList list = new ArrayList(20);中的 list 扩充几次? A. 0B...
208道最常见的Java面试题整理(面试必备)
适宜阅读人群 需要面试的初/中/高级 java 程序员 想要查漏补缺的人 想要不断完善和扩充自己 java 技术栈的人 java 面试官 具体面试题 下面一起来看 208 道面试题,具体的内容。 一、Java 基础 1.JDK 和 JRE 有什么区别? 2.== 和 equals 的区别是什么? 3.两个对象的 hashCode()相同,则 equals()也一定为...
判断链表是否有
1、如何<em>判断</em>一个<em>链表</em>是不是这类<em>链表</em>?  2、如果<em>链表</em>为存在<em>环</em>,如果找到<em>环</em>的入口点?解答:一、<em>判断</em><em>链表</em>是否存在<em>环</em>,办法为:设置两个指针(fast, slow),初始值都指向头,slow每次前进一步,fast每次前进二步,如果<em>链表</em>存在<em>环</em>,则fast必定先进入<em>环</em>,而slow后进入<em>环</em>,两个指针必定相遇。(当然,fast先行头到尾部为NULL,则为无<em>环</em><em>链表</em>)程序如下:bool IsExi
给定一个链表判断链表中是否有--Java版
题目描述: 单<em>链表</em>有<em>环</em>指的是单<em>链表</em>中某个节点的next域指向<em>链表</em>中在它之前的某一个节点,这样在<em>链表</em>的尾部形成一个<em>环</em>形结构。 <em>方法</em>一:HashSet 定义一个HasshSet用来存放节点的引用,并将其初始化为空,从<em>链表</em>的头节点开始向后遍历,每遍历到一个节点就<em>判断</em>HashSet中是否有这个节点的引用。如果没有,说明这个节点是第一次访问,还没有形成<em>环</em>,那么将这个节点的引用添加到HashSet中去。如果...
【Java数据结构】判断链表是否有,并且找出的入口
一:<em>判断</em>是否有<em>环</em> 思路:使用快慢引用法解决 是否有<em>环</em> 假设<em>链表</em>是一个有<em>环</em><em>链表</em>,且由f指向c构成<em>环</em>。那么 使用两个指针 A 和 B,让两指针同时向后遍历 而且B的遍历速度是A的两倍,呢么如果是有<em>环</em>的话,B终究会追上A。因此我们可以 以AB是否相遇作为<em>判断</em>是否有<em>环</em>的必要条件。 下面是图...
如何判断一个链表是否有
如何<em>判断</em>一个<em>链表</em>是否有<em>环</em> 问题陈述 ​ 如何<em>判断</em>一个<em>链表</em>是否有<em>环</em>,如果有,则返回第一个进入<em>环</em>的节点,没有则返回null。 思路 ​ 如果一个<em>链表</em>无<em>环</em>,那么遍历<em>链表</em>一定可以遇到<em>链表</em>的终点;如果<em>链表</em>有<em>环</em>,那么遍历<em>链表</em>就永远在<em>环</em>内转下去。具体如下: ​ 1.设置快慢指针分别为fast和slow。开始,slow和fast都指向<em>链表</em>的头节点head。然后slow每次移动一步,fast每次移动两部,在<em>链表</em>中遍...
java判断链表是否有
思路分析 假设,现在有一个存在<em>环</em>的单<em>链表</em>。 // null-&gt;node1-&gt;node2-&gt;node3-&gt;node4-&gt;node5-&gt;node6-&gt;node1 对其进行分析,可以设置2个“指针”。 singleStep 每次向后 更新一个节点;doubleStep 每次向后更新两个节点。 步骤如下: java代码 public ...
判断链表是否有,如果有找出的入口位置=>求两个相交链表的交点
http://beyrens.blog.163.com/blog/static/9589445220081013332452/ 首先如何<em>判断</em>一个<em>链表</em>是否有<em>环</em>: 设置两个指针(fast, slow),初始值都指向头,slow每次前进一步,fast每次前进二步,如果<em>链表</em>存在<em>环</em>,则fast必定先进入<em>环</em>,而slow后进入<em>环</em>,两个指针必定相遇。(当然,fast先行头到尾部为NULL,则为无<em>环</em><em>链表</em>)程序如
算法面试题:如何判断链表中是否存在
题目分析 一道算法面试题:<em>判断</em>单<em>链表</em>是否存在<em>环</em>。 我们知道单<em>链表</em>中结点都是一个结点指向下一个结点这样一个一个链接起来的,直到尾结点的指针域没有指向,单<em>链表</em>就到此结束了。 这里存在<em>环</em>的意思就是,尾结点的指针域并为空,而是指向此单<em>链表</em>的其他结点,这样就形成<em>环</em>了,这样遍历单<em>链表</em>就死循<em>环</em>了因为破坏了结束条件。 前面我们算法面试题 快速找到单<em>链表</em>中间节点 所用的快慢指针,同样可以用来<em>判断</em>是否存在<em>环</em>,
链表的经典实现(JAVA)
NULL 博文链接:https://128kj.iteye.com/blog/1744646
算法面试题:给定一个链表判断链表中是否有
转自:作者:LeetCode 链接:链接 来源:力扣(LeetCode) 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。 为了表示给定<em>链表</em>中的<em>环</em>,我们使用整数 pos 来表示<em>链表</em>尾连接到<em>链表</em>中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该<em>链表</em>中没有<em>环</em>。 示例 1: 输入:head = [3,2,0,-4], p...
java 判断链表
<em>环</em>形<em>链表</em> Given a linked list, determine if it has a cycle in it. To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed)in the linked list where ...
如何判断链表
2019独角兽企业重金招聘Python工程师标准&gt;&gt;&gt; ...
数据结构--java语言判断链表是否有
目录 1 题目描述 2 解题思路 3 代码实现 1 题目描述 给定一个<em>链表</em>,<em>判断</em>是否有<em>环</em>。 2 解题思路 定义两个引用:fast和slow,在合法的情况下,让fast一次走两步,slow一次走一步,若某次遍历时fast==slow,则说明该<em>链表</em>有<em>环</em>。 3 代码实现 //给定一个<em>链表</em>,<em>判断</em>是否有<em>环</em> public boolean hasCycle(){ No...
Java判断链表是否有的两种实现方法
package demo6;import java.util.HashMap;import demo6.LinkReverse2.Node; /** * <em>判断</em><em>链表</em>是否有<em>环</em>的<em>方法</em> * @author mengfeiyang * */ public class LinkLoop { public static boolean hasLoop(Node n){ //定义两个指
如何判断链表是否相交、判断链表判断相交链表第一个交点、判断链表入口节点
<em>判断</em>相交: 设置两个栈,分别将两个<em>链表</em>从第一个节点开始入栈,然后从栈顶开始比较出栈,如果第一个节点相等则相交,交点为最后一个相同节点。 <em>判断</em>有<em>环</em>: <em>方法</em>一:使用HashSet遍历<em>链表</em>,并存入节点ID,每遍历到一个新节点就将其ID与集合中已有ID进行比较,相同则有<em>环</em>,不同则存入集合继续遍历直至节点指向NULL则证明无<em>环</em>。 <em>方法</em>二:设置两个指针,一个fast每次前进2个节点,slow每次前进一个...
判断是否为链表
给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。 为了表示给定<em>链表</em>中的<em>环</em>,我们使用整数pos来表示<em>链表</em>尾连接到<em>链表</em>中的位置(索引从 0 开始)。 如果pos是-1,则在该<em>链表</em>中没有<em>环</em>。 可以用快慢指针的<em>方法</em>来解决该问题 /** * Definition for singly-linked list. * struct ListNode { * int val; * ...
java单链表关于链表是否有以及寻找入口
一:<em>判断</em><em>链表</em>是否为带<em>环</em><em>链表</em> 首先如何<em>判断</em><em>链表</em>是否有<em>环</em>,这个时候首先需要知道<em>链表</em>是否为空,如果不为空,则继续<em>判断</em>。 思路:首先定义两个变量,一个fast,一个slow,让fast 每次走两步,slow每次走一步,当fast和slow相遇时,即是该<em>链表</em>存在<em>环</em>结构。如果该<em>链表</em>为无<em>环</em>结构,则当遍历完这个<em>链表</em>时也不会相遇。即是返回false。 ...
链表-求链表的长度
//求<em>链表</em><em>环</em>的长度 public class Node{ public int value; public Node next; public Node(int data){ this.value=data; } } public int findLoopLength(Node head){ Node fast=head; Node...
判断一个单链表是否有的链接点(转)
给定一个单<em>链表</em>,只给出头指针h: 1、如何<em>判断</em>是否存在<em>环</em>? 2、如何知道<em>环</em>的长度? 3、如何找出<em>环</em>的连接点在哪里? 4、带<em>环</em><em>链表</em>的长度是多少?   解法: 1、对于问题1,使用追赶的<em>方法</em>,设定两个指针slow、fast,从头指针开始,每次分别前进1步、2步。如存在<em>环</em>,则两者相遇;如不存在<em>环</em>,fast遇到NULL退出。 2、对于问题2,记录下问题1的碰
如何判断链表中是否有
今天面试被问住了,很惭愧啊,回来上网查了一下思路。自己写了点程序。 1.如何<em>判断</em>是否有<em>环</em>?如果有两个头结点指针,一个走的快,一个走的慢,那么若干步以后,快的指针总会超过慢的指针一圈。 2.如何计算<em>环</em>的长度?第一次相遇(超一圈)时开始计数,第二次相遇时停止计数。 3.如何<em>判断</em><em>环</em>的入口点:碰撞点p到连接点的距离=头指针到连接点的距离,因此,分别从碰撞点、头指针开始走,相遇的那个点就是连接
算法题003 -- [判断链表中是否有,找到的入口节点] by java
程序运行截图: public class Node { // 这仅仅是一个标识,用来标记这是哪一个节点 public int tag; public Node next; public Node(Node next, int tag) { this.next = next; this.tag = tag; } // 逻辑断开 思路需要的tag public bool...
链表相交与链表
<em>链表</em>相交与求<em>环</em> 初看<em>链表</em>相交与<em>链表</em>求<em>环</em>,我还懵的,什么是<em>链表</em>相交?<em>链表</em>还能相交,什么是<em>链表</em>求<em>环</em>,<em>链表</em>还能求<em>环</em>,哈哈,直到看到这个。。。。。 <em>链表</em>中有<em>环</em> 看到这个图我才发现<em>链表</em>还可以这么玩,涨知识了。。不过同时看到这道题之后,也是勾起了浓厚的兴趣,那么我们到底该如何<em>判断</em><em>链表</em>相交与<em>链表</em>求<em>环</em>呢 - 首先我们来说一下<em>链表</em>相交的问题 开始看到这个问题的时候我也挺懵的,不知道如何去解决这个问题,不过只要你...
【图文解析】给定一个链表判断链表中是否有
目录例题描述解题思路代码实现 例题描述 给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。 为了表示给定<em>链表</em>中的<em>环</em>,我们使用整数 pos 来表示<em>链表</em>尾连接到<em>链表</em>中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该<em>链表</em>中没有<em>环</em>。 示例一: 输入:head = [3,2,0,-4], pos = 1 输出:true 解释:<em>链表</em>中有一个<em>环</em>,其尾部连接到第二个结点。 示例二: 输入:head = [1...
数据结构面试题之链表判断链表是否有?求的入口点
题目描述: <em>判断</em>一个<em>链表</em>中是否有<em>环</em>,有则找出<em>环</em>的入口节点 leetcode面试题链接:https://leetcode-cn.com/problems/linked-list-cycle-ii/description/ 题目分析: <em>判断</em><em>环</em>形<em>链表</em>的可能情况有以下三种: 基本思路: 由题可以看出<em>链表</em>为单<em>链表</em>,利用快慢指针,我们可以设置两个指针结点(fast,slow),初始化都指向<em>链表</em>的头...
两种判断链表方法
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; struct linknode { int data; linknode *next; }; int hasCycle(struct linknode *head) { struct linknode *fast, *slow; fast = head; ...
如何判断链表(三种方法
<em>方法</em>一、穷举遍历 <em>方法</em>一:首先从头节点开始,依次遍历单<em>链表</em>的每一个节点。每遍历到一个新节点,就从头节点重新遍历 新节点之前的所有节点,用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节 点当中存在相同节点ID,则说明该节点被遍历过两次,<em>链表</em>有<em>环</em>;如果之前的所有节点当中不存在相同的 节点,就继续遍历下一个新节点,继续重复刚才的操作。 例如这样的<em>链表</em>:A-&gt;B-&gt;...
链表是否有
题目:<em>判断</em>一个带头结点的单<em>链表</em>L是否有<em>环</em> 解题思路: 咋看之下,这题还真不好解,于是又一些投机取巧的人,在访问单<em>链表</em>中元素的时候,用一个比较大的数N控制访问元素的个数,他们认为如果在访问到第N个元素之前有一个元素为null,那么单<em>链表</em>没有<em>环</em>,反之,单<em>链表</em>有<em>环</em>。他们的解释是都访问了这么多元素了,还没有一个元素为空,单<em>链表</em>很有可能有<em>环</em>,再加上一般单<em>链表</em>中的元素都不超过N个,所以单<em>链表</em>有<em>环</em>。对于
如何判断一个单链表是否有
题目<em>要求</em>:给定一个单<em>链表</em>的头指针head,<em>要求</em>写一个函数<em>判断</em>这个单<em>链表</em>是否是一个有<em>环</em>单<em>链表</em>。 单<em>链表</em>中的节点定义如下: struct listNode { int val; struct listNode *next; }; <em>方法</em>1:首先定义一个map map,然后从单<em>链表</em>的头指针开始往后遍历,每次遇到一个指针p,就<em>判断</em>map[pCur]是否为0,若为0,则将map[pCur]赋
C语言单链表,并返回的起始节点
若<em>链表</em>中存在<em>环</em>,找出其中的<em>环</em>所在的节点,否则,返回NULL 在没有C++ set容器的优势前提下,我们对这样的<em>环</em>型的寻找以及定位可以利用快慢指针来实现。 有<em>环</em>的存在,类似与操场跑圈,必然存在快慢之分。有了快慢,就一定会有交点。反之,有了交点,就一定存在<em>环</em>。 实现过程如下: slow指针移动一次,fast指针移动两次,当fast指针和slow指针相等时保留相等时的节点 根据运算,从相等时的节点和...
链表,求长、链长;求两链表的交点
正是一个关于单<em>链表</em>的经典例题。即,给定一个有<em>环</em>的单<em>链表</em>,求<em>环</em>长、链长等。或者,给定一个单<em>链表</em>,<em>判断</em>是否有<em>环</em>? 可以遍历这个<em>链表</em>,将每一个节点存入一个有顺序的集合,同时<em>判断</em>当前节点是否在这个集合中出现,从而<em>判断</em>该<em>链表</em>是否有<em>环</em>以及求<em>环</em>长与链长。当时空间复杂度与时间复杂度都过大了。 另一个经典<em>方法</em>就是快慢指针,即两个指针同时从<em>链表</em>头开始走,快指针一次走2步,慢指针一次走1步。于是 假设这个有<em>环</em><em>链表</em>的j...
链表求入口点
给定一个<em>链表</em>,返回<em>链表</em>开始入<em>环</em>的第一个节点。 如果<em>链表</em>无<em>环</em>,则返回 null。 说明:不允许修改给定的<em>链表</em>。 看到这道题,我们首先应该想到的是<em>判断</em>这个<em>链表</em>是否有<em>环</em>,如果有<em>环</em>,找到入口点,否则返回true。 怎么<em>判断</em><em>链表</em>是否有<em>环</em>呢? 指定一个快指针和慢指针,快指针一次走两步,慢指针一次走一步。 如果没有<em>环</em>,快指针一定会遇到null; 如果有<em>环</em>,在经过一段时间后,快指针一定会和慢指针...
java实现约瑟夫问题(链表
Josephu (约瑟夫,约瑟夫<em>环</em>) 问题 Josephu问题为:设编号为1,2,3,。。。n的n个人围坐一圈,设定编号为k (1&lt;=k&lt;=n) 的人从1开始报数,数到m的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,以此类推,直到所有人出列为止,由此产生一个出队编号的序列。 提示:用一个不带头节点的循<em>环</em><em>链表</em>来处理约瑟夫问题:先构成一个有n个节点的单循<em>环</em><em>链表</em>,然后由k...
判断链表是否有...?
typedef struct LNode { int data; LNode *next; }LNode ; typedef LNode* LinkList; //单<em>链表</em>有<em>环</em>返回true 否则返回f
判断链表是否有判断的入口
pre 面试中遇到过,知道解法,但是细节不是很了解,这里重新整理一下思路,通知给出关键部分的理由和证明 问题1:<em>判断</em><em>链表</em>是否有<em>环</em> 问题分析 首先考虑<em>环</em>出现之后<em>链表</em>的特征,从头开始的<em>链表</em>遍历无法结束,也就是不存在尾节点 这时候第一个想法,一遍遍历<em>链表</em>,直至出现null 或者下一个元素是之前出现过的元素,那么这样时间复杂度为O(n),空间复杂度为O(n)[这里需要缓存之前节点的访问的...
判读一个链表中是否有(Leetcode141--链表
Leetcode141–<em>环</em>形<em>链表</em> 给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。 编程语言:python 作者:黑暗主宰 邮箱:shengzhanhe@gmail.com 文章目录Leetcode141--<em>环</em>形<em>链表</em>题目描述解题思路 Leetcode141–<em>环</em>形<em>链表</em> 题目描述 原题链接: ​ https://leetcode-cn.com/problems/linked-list-cycle/ (中文) ​ ...
JAVA:链表判断链表是否存在
【题目描述】Given a linked list, determine if it has a cycle in it. Follow up: Can you solve it without using extra space? 给定单<em>链表</em>,<em>判断</em>是否存在<em>环</em>?不适用额外空间 【知识点】: <em>环</em><em>链表</em>:从<em>判断</em>一个单<em>链表</em>是否存在循<em>环</em>而扩展衍生的问题,有则称之为有<em>环</em><em>链表</em>问题。 【解决
给定一个链表判断链表中是否有
通过反转<em>链表</em>来做,这样破坏了原来的<em>链表</em>:如果没有<em>环</em>,则<em>链表</em>头变了 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ cla...
如何判断链表是否有
背景 :    例如在一个大的系统中,如果出现两个<em>链表</em>相交的情况,而且释放其中一个<em>链表</em>所有的节点,那就会造成信息的丢失, 并且释放其中一个<em>链表</em>的所有节点,那就会造成信息的丢失并且与之相交的<em>链表</em>也会受到影响, 如下图: 给出两个单<em>链表</em>的头指针 h1,h2(假设两个<em>链表</em>均不带<em>环</em>)    <em>方法</em>一:  <em>判断</em>第一个<em>链表</em>所有的节点是否在第二个<em>链表</em>中,这种<em>方法</em>时间复杂度为  O(h1)*O (h2)
链表判断(Java实现)
<em>方法</em>一:通过快慢指针的方式来解决 //本<em>方法</em>未经测试,如有问题请多包容boolean isLoopListTable(ListNode head){ ListNode headFirst=head; ListNode headLenT=head; ListNode headLenO=head; boolean res=false; while(1){
java 实现循链表
2019独角兽企业重金招聘Python工程师标准&gt;&gt;&gt; ...
leetcode刷题(141)——判断链表是否有
Given a linked list, determine if it has a cycle in it. To represent a cycle in the given linked list, we use an integerposwhich represents the position (0-indexed)in the linked list where tail c...
leetcode-141 链表(LinkedListCycle)-java
题目:<em>环</em>形<em>链表</em>给定一个<em>链表</em>,<em>判断</em><em>链表</em>中是否有<em>环</em>。进阶:你能否不使用额外空间解决此题?public boolean hasCycle(ListNode head) { if (head == null || head.next == null) return false; ListNode fast = head; ListNode slow = head; ...
题目:代码实现判断链表是否有
一、单<em>链表</em><em>环</em>的定义: 有<em>环</em>的定义是,<em>链表</em>的尾节点指向了链接中间的某个节点。比如下图,如果单<em>链表</em>有<em>环</em>,则在遍历时,在通过结点J之后,会重新回到结点D。 题目:0.如何<em>判断</em>单<em>链表</em>里面是否有<em>环</em>? 算法的思想是设定两个指针p, q,其中p每次向前移动一步,q每次向前移动两步。那么如果单<em>链表</em>存在<em>环</em>,则p和q相遇;否则q将首先遇到null。 这里主要理解一个问题,就是为什么当单<em>链表</em>
判断一个单链表是否有,若有,找出的入口节点
题目:如何<em>判断</em>一个单<em>链表</em>是否有<em>环</em>?若有<em>环</em>,如何找出<em>环</em>的入口节点。 一、单<em>链表</em>是否有<em>环</em> 思路分析: 单<em>链表</em>有<em>环</em>,是指单<em>链表</em>中某个节点的next指针域指向的是<em>链表</em>中在它之前的某一个节点,这样在<em>链表</em>的尾部形成一个<em>环</em>形结构。<em>判断</em><em>链表</em>是否有<em>环</em>,有以下几种<em>方法</em>。// <em>链表</em>的节点结构如下 typedef struct node { int data; struct node *next; }
链表是否有的两种判断方法
<em>判断</em>单<em>链表</em>是否有<em>环</em> 假设有一个含<em>环</em><em>链表</em>:1-2-3-4-5-6-3(6又连接到3,形成一个<em>环</em>)   使用p、q两个指针,p总是向前走,但q每次都从头开始走,对于每个节点,看p走的步数是否和q一样。当p从6走到3时,用了6步;此时q从head出发,则只需两步就到3,因而步数不等,出现矛盾,存在<em>环</em>。而且可以锁定<em>环</em>的位置,就是q的步数+1   使用p、q两个指针,p每次向前走一步,q每次向前走...
Java实现有的单向链表,并判断单向链表是否有
有一个单向<em>链表</em>,<em>链表</em>当中有可能出现<em>环</em>,就像下图这样。我们如何<em>判断</em>一个单向<em>链表</em>是否有<em>环</em>呢? 那么第一步,我们先实现一个这样的<em>链表</em>,接着再说如何<em>判断</em>这样的<em>链表</em>。 实现有<em>环</em>的单向<em>链表</em> 1、定义add(Node node)<em>方法</em> /** * 向<em>链表</em>末尾添加结点 * * @param node 结点的next指向为null,表示尾结点。 * @return ...
今天在一个公司应聘,应聘完之后……(给了一个面试题)
我是一个大三的本科学生,对.net极其的热爱,本着这份热爱,我逃了不少课,来专注于它,很想找个机会出去找个工作试试自己的实力,现在在高校里做过大大小小的十多个项目,有一些开发经验了。这里就专业技能就不
快速排序枢纽值(基元)选择方法(转载)
转自: 无知的小七何时你能长大的博客 http://blog.sina.com.cn/u/1952393755  对于分治算法,当每次划分时,算法若都能分成两个等长的子序列时,那么分治算法效率会达到最大。也就是说,基准的选择是很重要的。选择基准的方式决定了分割后两个子序列的长度,进而对整个算法的效率产生决定性影响。最理想的<em>方法</em>是,选择的基准恰好能把待排序序列分成两
判断一个链表是否有
<em>判断</em>一个<em>链表</em>是否有<em>环</em>(c/c++实现)<em>方法</em>一<em>方法</em>二<em>方法</em>三 给出一个单向<em>链表</em>,<em>判断</em><em>链表</em>中是否存在<em>环</em>。虽然是一个实际工作中基本不会碰到的场景,但是面试的时候总是会考到,因此整理下各种解法,以免需要的时候用到。温故而知新! <em>方法</em>一 第一种<em>方法</em>是大家都能想到的,就是利用空间来换时间:遍历<em>链表</em>中的每一个节点,放入一个容器中(此处使用std::set,查找速度快),每次插入容器的时候,<em>判断</em>是否已经存在相同节点...
判断单向链表中是否有C++实现
原文:https://blog.csdn.net/caoshangpa/article/details/80363335 <em>判断</em><em>链表</em>是否有<em>环</em>的经典的<em>方法</em>是快慢指针的<em>方法</em>。 快指针pf每次移动两个节点,慢指针ps每次移动一个节点,如果指针可以追上慢指针,那就说明其中有一个<em>环</em>,反之没有。 结论:<em>链表</em>存在<em>环</em>,则fast和slow两指针必然会在slo...
怎么判断一个单向链表是否有回(笔试题)
怎么<em>判断</em>一个单向<em>链表</em>是否有回<em>环</em>? 即表尾指针不是空,可能指向前面的某一个接点
LeetCode142.链表 II(Java实现)
LeetCode链接:https://leetcode-cn.com/problems/linked-list-cycle-ii/submissions/ 思路一: 同141题,快慢指针 1.<em>链表</em>判空 2.设置两个指针q和s,均从head开始 3.只要q不为空或者q下一跳不为空,q向后移两位,s向后移移位 4.移动过程中,如果q和s相遇,则退出3循<em>环</em> 5.此时q如果为空或者q的下...
判断链表是否有的java实现
无论面试还是笔试经常会考这样一道题:怎么<em>判断</em>一个单<em>链表</em>是否存在<em>环</em>? java实现代码如下:package Demo1; public class LinkedLoop { //内部静态类定义结点类 static class Node{ int val; Node next; public Node(int val){ this.val = val; } } //判
判断链表是否有,并找出的入口【python】
 参考链接:数据结构面试 之 单<em>链表</em>是否有<em>环</em>及<em>环</em>入口点 附有最详细明了的图解 - 简书 https://www.jianshu.com/p/ef71e04241e4 <em>判断</em>单向列表是否包括<em>环</em>,若包含,<em>环</em>入口的节点计算 python实现 - 鲸落丶 - 博客园 https://www.cnblogs.com/kunpengv5/p/7784791.html <em>判断</em><em>链表</em>是否有<em>环</em>以及<em>环</em>的入口点(...
判断单向链表中是否有和查找的入口
快慢指针算法描述定义两个指针slow, fast。slow指针一次走1个结点,fast指针一次走2个结点。如果<em>链表</em>中有<em>环</em>,那么慢指针一次会再某一个时刻追上快指针(slow == fast)。如果没有<em>环</em>,则快指针会第一个走到NULL。实现结点定义如下:class Node { public Node next; public Object data; public static
判断两个链表是否相交并找出交点
问题描述: 一个比较经典的问题,<em>判断</em>两个<em>链表</em>是否相交,如果相交找出他们的交点。 思路: 1、碰到这个问题,第一印象是采用hash来<em>判断</em>,将两个<em>链表</em>的节点进行hash,然后<em>判断</em>出节点,这种想法当然是可以的。 2、当然采用暴力的<em>方法</em>也是可以的,遍历两个<em>链表</em>,在遍历的过程中进行比较,看节点是否相同。 3、第三种思路是比较奇特的,在编程之美上看到的。先遍历第一个<em>链表</em>到
如何判断链表,并找出的入口
如何<em>判断</em>单<em>链表</em>有<em>环</em>,并找出<em>环</em>的入口? 时间O(n)O(n),空间O(1)O(1)。 这个面试题还是蛮有趣的,当时只想出了第一问,第二问实在巧妙。 如图这个单<em>链表</em>,蓝色的部分是<em>环</em>。 对于如何<em>判断</em><em>链表</em>有<em>环</em>,可以从起点发出两个指针,一个一次一步,另一个一次两步,如果两个指针相遇,那么这个单<em>链表</em>就有<em>环</em>。 设绿色的地方是指针相遇点。 对于第二问求<em>环</em>的入口,从第一问的相遇点和起点各发出一个速
[算法]判断一个链表是否有
如何<em>判断</em>一个<em>链表</em>是否有<em>环</em>解题思路: 定义两个指针fast和slow,其中fast是快指针,slow是慢指针,二者的初始值都指向<em>链表</em>头,slow每前进一步,fast每次前进两步,两个指针同时向前移动,快指针每移动一次都要和慢指针比较,直到当快指针等于慢指针为止,就证明这个<em>链表</em>是带<em>环</em>的单向<em>链表</em>,否则,证明这个<em>链表</em>是不带<em>环</em>的循<em>环</em><em>链表</em>(fast先行到达尾部为NULL,则为无<em>环</em><em>链表</em>)。 代码实现如下:pu
判断链表是否有并求出的起点
<em>判断</em><em>链表</em>有无<em>环</em>的<em>方法</em>: 设置一个快指针速度  != 慢指针的速度,这就是物理里的相遇问题,我开始犯了一个错,我设置快指针和慢指针的速度相等,所以答案出错,原因是速度相等,那么它们在坐标轴上的速度永远是平行的,除非数组的长度很小,可以相遇一次,否则不能相遇。 如果快指针和慢指针相遇则有<em>环</em>。 求<em>环</em>的起点:当两指针相遇的时候,将快指针指向<em>链表</em>起点,并且速度设置为和慢指针速度相等,当两指针相
如何判断一个链表是否有,如果有,并找出的入口
http://blog.csdn.net/gukesdo/article/details/7516021 首先如何<em>判断</em>一个<em>链表</em>是否有<em>环</em>: 设置两个指针(fast, slow),初始值都指向头,slow每次前进一步,fast每次前进二步,如果<em>链表</em>存在<em>环</em>,则fast必定先进入<em>环</em>,而slow后进入<em>环</em>,两个指针必定相遇。(当然,fast先行头到尾部为NULL,则为无<em>环</em><em>链表</em>)程序如下:
[算法]判断一个链表是否有开始的位置
这是一道很常见的面试问题,,只用两个变量通过O(n)的时间复杂度就可以解决。 Floyd cycle detection算法,也叫做tortoise and hare算法,龟兔算法吧。以下内容为对解法做一归纳,参考了stackoverflow论坛的讨论问题:如何检测一个<em>链表</em>是否有<em>环</em>,如果有,那么如何确定<em>环</em>的起点.龟兔解法的基本思想可以用我们跑步的例子来解释,如果两个人同时出发,如果赛道有<em>环</em>,那么快
判断一个单链表中是否存在
#<em>判断</em>一个单<em>链表</em>中是否存在 <em>环</em>。 #设置两个指针(fast, slow),初始值都指向头,slow每次前进1步,fast每次前进2步, 大概的思路如下: 如果<em>链表</em>存在<em>环</em>,则fast必定先进入<em>环</em>,而slow后进入<em>环</em>,两个指针必定相遇。 如果<em>链表</em>不存在<em>环</em>,则fast必定先指向NULL,而slow后指向NULL。 如果存在<em>环</em>,则返回1;     否则,返回0 int IsExit
判断链表的三种方法
<em>判断</em><em>链表</em>是否有<em>环</em>的三种<em>方法</em>  1. 在节点ListNode中增加一个域,用于记录此节点是否已经被访问,如下ListNode中被注释掉代码。此<em>方法</em>简单,能找出<em>环</em>开始的节点,但是增加了<em>链表</em>的开销。如果<em>链表</em>非常大 则需要十分大的内存来保存此域。 2. 使用<em>链表</em>逆序的<em>方法</em>。从头结点开始一直将<em>链表</em>逆序,头结点的next域为空。如果有<em>环</em>的话<em>链表</em>逆序必定会回到头节点而终止。这种做法同样简单,确保O(n)时间...
华为面试题:怎么判断链表中是否有?????
华为面试题:怎么<em>判断</em><em>链表</em>中是否有<em>环</em>????? 该<em>链表</em>不一定是循<em>环</em>单<em>链表</em>或双<em>链表</em>。
链表--如何检测一个链表是否有及如何找到的入口点
如何检测一个<em>链表</em>是否有<em>环</em> 有<em>环</em>的<em>链表</em>: 有<em>环</em>的<em>链表</em>是指<em>链表</em>有<em>环</em>路,例如A-&amp;amp;gt;B-&amp;amp;gt;C-&amp;amp;gt;D-&amp;amp;gt;E-&amp;amp;gt;F-&amp;amp;gt;B,遍历的时候B-&amp;amp;gt;C-&amp;amp;gt;D-&amp;amp;gt;E-&amp;amp;gt;F-&amp;amp;gt;B会形成<em>环</em>路一直循<em>环</em>。 思路: 设置一个快指针fast,一个慢指针slow,二者初始都指向<em>链表</em>头,fas
判断一个链表是否有(快慢指针)
1. 问题描述: 给出一个<em>链表</em><em>判断</em>该<em>链表</em>是否有<em>环</em> 2. 我们可以使用一种比较经典的方式来进行处理,就是使用两个指针来进行移动,一个为快指针,一个为慢指针,快指针一次移动两步,慢指针一次移动一步,假如<em>链表</em>有<em>环</em>的话那么这两个指针一定会在某一个地方会相遇的,为什么呢?<em>有没有</em>可能不会相遇呢?答案是不可能的,两个指针一定会在某一个位置上相遇,因为假如它们没有相遇,快指针的位置为i + 1,那么慢指针的位...
判断链表是否有的两种方法
如图,如果单<em>链表</em>有<em>环</em>,则在遍历时,在通过6之后,会重新回到3,那么我们可以在遍历时使用两个指针,看两个指针是否相等。 <em>方法</em>一:使用p、q两个指针,p总是向前走,但q每次都从头开始走,对于每个节点,看p走的步数是否和q一样。如图,当p从6走到3时,用了6步,此时若q从head出发,则只需两步就到3,因而步数不等,出现矛盾,存在<em>环</em><em>方法</em>二:使用p、q两个指针,p每次向前走一步,q每次向前走两步,若...
检测链表是否有,并且找到的入口
第一步:检测<em>链表</em>是否有<em>环</em>。 <em>方法</em>还是比较多的,这里先讲一个:快慢指针。 快慢指针的<em>方法</em>,就是让两个指针同时指向<em>链表</em>。在向后遍历的时候,一个指针每次走两步,称为快指针;一个指针每次走一步,称为慢指针。如果快慢指针相遇,则说明<em>链表</em>有<em>环</em>,否则无<em>环</em>。(后面证明。) 代码实现如下: // 如果有<em>环</em>,则返回快慢指针相遇点。如果没<em>环</em>,则返回NULL。 position IsLoop(list l...
面试算法:链表的检测
在有关<em>链表</em>的面试算法题中,检测<em>链表</em>是否有<em>环</em>是常见的题目。给定一个<em>链表</em>,<em>要求</em>你<em>判断</em><em>链表</em>是否存在循<em>环</em>,如果有,给出<em>环</em>的长度,<em>要求</em>算法的时间复杂度是O(N), 空间复杂度是O(1)
链表检测以及入口
/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; */ class Solution { public: ListNode* detectCycle(ListNode* head) { ListN...
判断链表是否有,求的入口点及
今天的内容主要包括三部分,RT。 1。<em>判断</em><em>链表</em>是否带<em>环</em> <em>判断</em><em>链表</em>是否带<em>环</em>,我们可以采用在头结点设两个指针,一个叫fast,一个叫slow,fast一下走两步,而slow一下走一步。如果<em>链表</em>中存在<em>环</em>的话,那么fast和slow必定会在<em>环</em>中相遇。若<em>链表</em>中没有<em>环</em>的话,那么fast必定现于slow指针先到达<em>链表</em>的尾节点(->next = Null)。我们现在来思考一个问题,为什么<em>链表</em>中存在<em>环</em>,
判断链表是否有,若有,寻找节点
<em>判断</em><em>方法</em>,创建两个指针p和q指针,p指针每次向前前进一个,q每次向前前进两个。如果存在p和q一起指向同一个结点,则证明有<em>环</em>。 反之如果的下一个结点为空,则无<em>环</em>。 如果有<em>环</em>,则p到<em>环</em>的结点时,q一定领先p的距离为b(小于<em>环</em>的长度n),此时p和q相遇假设需要前进y次,则q相比p多走了距离y,能够相遇可以假设q比p多走了m圈,则y+b=mn,假设m=1,则y+b=n。y+b因为p到<em>环</em>结点时,
动态规划入门到熟悉,看不懂来打我啊
持续更新。。。。。。 2.1斐波那契系列问题 2.2矩阵系列问题 2.3跳跃系列问题 3.1 01背包 3.2 完全背包 3.3多重背包 3.4 一些变形选讲 2.1斐波那契系列问题 在数学上,斐波纳契数列以如下被以递归的<em>方法</em>定义:F(0)=0,F(1)=1, F(n)=F(n-1)+F(n-2)(n&gt;=2,n∈N*)根据定义,前十项为1, 1, 2, 3...
Java学习的正确打开方式
在博主认为,对于入门级学习java的最佳学习<em>方法</em>莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章中,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍,博客次之,这又是一个层次了,这里暂时不提后面再谈。博主将为各位入门java保驾护航,各位只管冲鸭!!!上天是公平的,只要不辜负时间,时间自然不会辜负你。 何谓学习?博主所理解的学习,它是一个过程,是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。
05PowerPoint.ppt下载
05PowerPoint.ppt 相关下载链接:[url=//download.csdn.net/download/qq1051990578/4597622?utm_source=bbsseo]//download.csdn.net/download/qq1051990578/4597622?utm_source=bbsseo[/url]
原道n70s刷机程序下载
原道n70s刷机程序,可以运行在xp和win7系统中 相关下载链接:[url=//download.csdn.net/download/baidu_15299369/7335947?utm_source=bbsseo]//download.csdn.net/download/baidu_15299369/7335947?utm_source=bbsseo[/url]
Net cut.exe下载
管理局域网内计算机上网的 相关下载链接:[url=//download.csdn.net/download/huanghua6/419648?utm_source=bbsseo]//download.csdn.net/download/huanghua6/419648?utm_source=bbsseo[/url]
相关热词 c#时间格式化 不带- c#替换字符串中指定位置 c# rdlc 动态报表 c# 获取txt编码格式 c#事件主动调用 c#抽象工厂模式 c# 如何添加类注释 c# static块 c#处理浮点数 c# 生成字母数字随机数
我们是很有底线的