转：链表相交问题 详解

源地址：http://blog.163.com/bbluesnow@126/blog/static/27784545201251051156817/

链表相交问题  

2012-06-10 17:15:37|  分类： 算法 |  标签：微软面试题  |字号 订阅

1、如何判断一个单链表有环

2、如何判断一个环的入口点在哪里

3、如何知道环的长度

4、如何知道两个单链表（无环）是否相交

5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么？

6、如何知道两个单链表（有环）是否相交

7、如果两个单链表（有环）相交，如何知道它们相交的第一个节点是什么？

 以下进行分析，并在最后附源代码及测试：

1、采用快慢步长法。令两个指针p和q分别指向头结点，p每次前进一步，q每次前进两步，如果p和q能重合，则有环。可以这么理解，这种做法相当于p静止不动，q每次前进一步，所有肯定有追上p的时候。

我们注意到，指针p和q分别以速度为1和2前进。如果以其它速度前进是否可以呢？

假设p和q分别以速度为v1和v2前进。如果有环，设指针p和q第一次进入环时，他们相对于环中第一个节点的偏移地址分别为a和b（可以把偏移地址理解为节点个数）

这样，可以看出，链表有环的充要条件就是某一次循环时，指针p和q的值相等，就是它们相对环中首节点的偏移量相等。我们设环中的结点个数为n,程序循环了m次。

由此可以有下面等式成立：(mod(n)即对n取余)

(a+m*v1)mod(n) = (b+m*v2) mod(n)

设等式左边mod(n)的最大整数为k1，等式右边mod(n)的最大整数为k2，则

(a+m*v1)-k1*n = (b+m*v2)-k2*n

整理以上等式：

m= |((k2-k1)*n+a-b)/( v2-v1)|       ①

如果是等式①成立，就要使循环次数m为一整数。显然如果v2-v1为1，则等式成立。

这样p和q分别以速度为v1和v2且|v2-v1|为1时，按以上算法就可找出链表中是否有环。当然|v2-v1|不为1时，也可能可以得出符合条件的m。

 

时间复杂度分析：假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2，链表总长度为n，则n=len1+len2。当p步长为1，q步长为2时，p指针到达环入口需要len1时间，p到达入口后，q处于哪里不确定，但是肯定在环内，此时p和q开始追赶，q最长需要len2时间就能追上p（p和q都指向环入口），最短需要1步就能追上p（p指向环入口，q指向环入口的前一个节点）。事实上，每经过一步，q和p的距离就拉近一步，因此，经过q和p的距离步就可以追上p。因此总时间复杂度为O(n)，n为链表的总长度。

 

 

2、分别从链表头和碰撞点，同步地一步一步前进扫描，直到碰撞，此碰撞点即是环的入口。

证明如下：

链表形状类似数字 6 。 

假设甩尾（在环外）长度为 a（结点个数），环内长度为 b 。 

则总长度（也是总结点数）为 a+b 。 

从头开始，0 base 编号。

将第 i 步访问的结点用 S(i) 表示。i = 0, 1 ... 

当 i＜a 时，S(i)=i ； 

当 i≥a 时，S(i)=a+(i-a)%b 。

分析追赶过程。 

两个指针分别前进，假定经过 x 步后，碰撞。则有：S(x)=S(2x) 

由环的周期性有：2x=tb+x 。得到 x=tb 。 

另，碰撞时，必须在环内，不可能在甩尾段，有 x>=a 。

连接点为从起点走 a 步，即 S(a)。 

S(a) = S(tb+a) = S(x+a)。 

得到结论：从碰撞点 x 前进 a 步即为连接点。

根据假设易知 S(a-1) 在甩尾段，S(a) 在环上，而 S(x+a) 必然在环上。所以可以发生碰撞。 

而，同为前进 a 步，同为连接点，所以必然发生碰撞。

综上，从 x 点和从起点同步前进，第一个碰撞点就是连接点。

 

 

时间复杂度分析：假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2 。则时间复杂度为“环是否存在的时间复杂度”+O（len1）

 

 

3、从碰撞点开始，两个指针p和q，q以一步步长前进，q以两步步长前进，到下次碰撞所经过的操作次数即是环的长度。这很好理解，比如两个运动员A和B从起点开始跑步，A的速度是B的两倍，当A跑玩一圈的时候，B刚好跑完两圈，A和B又同时在起点上。此时A跑的长度即相当于环的长度。

假设甩尾（在环外）长度为 len1（结点个数），环内长度为 len2 ，则时间复杂度为“环是否存在的时间复杂度”+O(len2)。

 

4、法一：将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个新链表。问题转化为求这个新链表是否有环的问题。

     时间复杂度为环是否存在的时间复杂度，即O（length(A)+length(B)），使用了两个额外指针

     法二：两个链表相交，则从相交的节点起，其后的所有的节点都是都是两个链表共有的。因此，如果它们相交，则最后一个节点一定是共有的。因此，判断两链表相交的方法是：遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交。

     时间复杂度：O（length(A)+length(B)），但是只用了一个额外指针存储最后一个节点

 

5、将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个环。问题转化为求这个环的入口问题。
时间复杂度：求环入口的时间复杂度

 

6、分别判断两个链表A、B是否有环（注，两个有环链表相交是指这个环属于两个链表共有）

如果仅有一个有环，则A、B不可能相交

如果两个都有环，则求出A的环入口，判断其是否在B链表上，如果在，则说明A、B相交。

时间复杂度：“环入口问题的时间复杂度”+O（length（B））

 

7、分别计算出两个链表A、B的长度LA和LB（环的长度和环到入口点长度之和就是链表长度），参照问题3。

如果LA>LB，则链表A指针先走LA-LB，链表B指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

如果LB>LA，则链表B指针先走LB-LA，链表A指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

时间复杂度：O（max（LA,LB））

源码，并没有封装成类，存在某些重复运算：

islistJunction.

 

/******************************************************************************************************
Description   : 检查链表是否有环
Prototype     : template<typename T>
    bool checkCircle(T* head)
Input Param   : head，链表的头结点指针
Output Param  : 无
Return Value  : bool变量，TRUE为有环，FALSE为没有环
********************************************************************************************************/
template<typename T>
bool checkCircle(T* head)
{
 if(NULL == head)
  returnfalse;
 T* low = head;
 T* fast = head;

 while(low->next!= NULL &&(fast->next!= NULL)&&(fast->next)->next!= NULL)
 {
  low = low->next;
  fast =(fast->next)->next;
  if(low == fast)
  {
   returntrue;
  }
 }
 returnfalse;
}

/******************************************************************************************************
Description   : 判断两个链表是否相交
Prototype     : template<typename T>
    bool isListJunction(T* head1,T* head2)
Input Param   : head1，第一个链表的头结点；head2，第二个链表的头结点
Output Param  : 无
Return Value  : bool变量，true为有交集，false为没有交集
********************************************************************************************************/
template<typename T>
bool isListJunction(T* head1,T* head2)
{
 if(NULL == head1 || NULL == head2)
 {
  returnfalse;
 }
 // 如果头结点相同，代表相同的链表，肯定是相交
 if(head1 == head2)
 {
  returntrue;
 }
 
 // 检测是否有环
 bool b1 = checkCircle(head1);
 bool b2 = checkCircle(head2);
 // 若相交，则两个链表要么都无环，要么都有环
 if(b1 != b2)
 {
  returnfalse;
 }
 
 // 若都无环，b1==b2==0,尾节点必然相同，是Y字形
 if(!b1)
 {
  while(head1 != NULL)
  {
   head1 = head1->next;
  }
  while(head2 != NULL)
  {
   head2 = head2->next;
  }
  if(head1 == head2)
  {
   returntrue;
  }
 }

 // 若有环，则找出链表1的环入口，看是否在链表2上
 if(b1)
 {
  T* port = findLoopPort(head1);
  if(port != NULL)
  {
   T* temp = head2;
   int length2 = getLoopLength(head2)+ getTailLength(head2);
   while(port != temp &&(length2--)>=0)
    temp = temp->next;

   if(port == temp)
    returntrue;
   else
    returnfalse;
  }
 }
 
 returnfalse;
}

/******************************************************************************************************
Description   : 判断两个链表是否相交
Prototype     : template<typename T>
    bool isListJunction(T* head1,T* head2)
Input Param   : head1，第一个链表的头结点；head2，第二个链表的头结点
Output Param  : 无
Return Value  : bool变量，true为有交集，false为没有交集
********************************************************************************************************/
template<typename T>
bool isListJunction(T* head1,T* head2,T *&junctionNode)
{
 if(NULL == head1 || NULL == head2)
 {
  returnfalse;
 }
 // 如果头结点相同，代表相同的链表，肯定是相交
 if(head1 == head2)
 {
  junctionNode = head1;
  returntrue;
 }
 
 // 检测是否有环
 bool b1 = checkCircle(head1);
 bool b2 = checkCircle(head2);
 // 若相交，则两个链表要么都无环，要么都有环
 if(b1 != b2)
 {
  returnfalse;
 }
 
 // 若都无环，b1==b2==0,尾节点必然相同，是Y字形
 if(!b1)
 {
  T* node1 = head1;
  T* node2 = head2;
  while(node1 != NULL)
  {
   node1 = node1->next;
  }
  while(node2 != NULL)
  {
   node2 = node2->next;
  }
  if(node1 == node2)
  {
   // 相交，把第一个链表的尾节点指向第二个链表
   node1->next= head2;
   junctionNode = findLoopPort(head1);
   returntrue;
  }
 }

 // 若有环，则找出链表1的环入口，看是否在链表2上
 if(b1)
 {
  int length1 = getLoopLength(head1)+ getTailLength(head1);
  int length2 = getLoopLength(head2)+ getTailLength(head2);
  int len = length2;
  T* port = findLoopPort(head1);
  if(port != NULL)
  {
   T* temp = head2;
   while(port != temp &&(len--)>=0)
    temp = temp->next;

   if(port == temp)
   {
    // 若长度相等，同步寻找相同的节点
    if(length1 == length2)
    {
     while(head1 != head2)
     {
      head1 = head1->next;
      head2 = head2->next;
     }
     junctionNode = head1;
    }
    // 若长度不等，长的先剪掉长度差，然后再同步递增
    elseif(length1 > length2)
    {
     int step = length1 - length2;
     while(step--)
     {
      head1 = head1->next;
     }
     while(head1 != head2)
     {
      head1 = head1->next;
      head2 = head2->next;
     }
     junctionNode = head1;
    }
    else
    {
     int step = length2 - length1;
     while(step--)
     {
      head2 = head2->next;
     }
     while(head1 != head2)
     {
      head1 = head1->next;
      head2 = head2->next;
     }
     junctionNode = head1;
    }
    returntrue;
   }
   else
   {
    returnfalse;
   }
  }
 }
 
 returnfalse;
}

/******************************************************************************************************
Description   : 查找环的入口
Prototype     : template<typename T>
    T* findLoopPort(T* head)
Input Param   : head，链表的头结点
Output Param  : 无
Return Value  : 环入口点的指针
********************************************************************************************************/
template<typename T>
T* findLoopPort(T* head)
{
 // 判断是否有环，五环返回NULL
 checkCircle(head);
 if(!checkCircle(head))
  return NULL;

 T* low = head;
 T* fast = head;

 // low按照步长1增加，fast按照步长2增加，找到碰撞点
 while(1)
 {
  low = low->next;
  fast = fast->next->next;
  if(low == fast)
   break;
 }
 
 // 分别从头结点和碰撞节点开始按照步长1增加，遍历链表，第一个节点相同的点是环入口点
 low = head;
 while(low != fast)
 {
  low = low->next;
  fast = fast->next;
 }

 return low; 
}

/******************************************************************************************************
Description   : 计算环的长度
Prototype     : template<typename T>
    int getLoopLength(T* head)
Input Param   : head，链表的头结点
Output Param  : 无
Return Value  : int，表示长度
********************************************************************************************************/
template<typename T>
int getLoopLength(T* head)
{
 if(!checkCircle(head))
  return0;
 

 T* low = head;
 T* fast = head;
 int length =0;

 // low按照步长1增加，fast按照步长2增加，找到碰撞点,然后接着循环直到下一次碰撞，
 // 计算两次碰撞之间的循环次数即为长度
 while(1)
 {
  low = low->next;
  fast = fast->next->next;
  if(low == fast)
   break;
 }
 while(1)
 {
  low = low->next;
  fast = fast->next->next;
  length++;
  if(low == fast)
   break;

 }
 return length;
}

/******************************************************************************************************
Description   : 计算有环链表的尾长度
Prototype     : template<typename T>
    int getTailLength(T* head)
Input Param   : head，链表的头结点
Output Param  : 无
Return Value  : int，表示长度
********************************************************************************************************/
template<typename T>
int getTailLength(T* head)
{
 T* port = findLoopPort(head);
 int length =0;
 T* temp = head;

 while(temp != port)
 {
  length++;
  temp = temp->next;
 }
 return length;
}

main.cpp

#include"isListJunction.h"
#include<string>

template<typename T>
struct listNode
{
 T val;
 listNode *pre;
 listNode *next;

 listNode()
 {
  pre = NULL;
  next= NULL;
 }

 listNode(T value)
 {
  val = value;
  pre = NULL;
  next= NULL;
 }
};

int main(int argc,char** argv)
{
 string first ="my is";
 string second ="your";
 string three ="is";
 string four ="king";
 string five ="name";
 string first2 ="speak";
 string second2 ="what";

 list<string> firstlist;
 firstlist.push_back(first);
 firstlist.push_back(second);
 firstlist.push_back(three);
 firstlist.push_back(four);
 firstlist.push_back(five);

 list<string> secondlist;
 secondlist.push_back(first2);
 secondlist.push_back(second2);
 secondlist.push_back(four);
 secondlist.push_back(five);

 // 链表1，无环
 listNode<string>*head1 =new listNode<string>(first);
 listNode<string>*pnode2 =new listNode<string>(second);
 head1->next= pnode2;
 listNode<string>*pnode3 =new listNode<string>(three);
 pnode2->next= pnode3;
 listNode<string>*pnode4 =new listNode<string>(four);
 pnode3->next= pnode4;
 listNode<string>*pnode5 =new listNode<string>(five);
 pnode4->next= pnode5;

 // 链表2，无环
 listNode<string>*head2 =new listNode<string>(first2);
 listNode<string>*pnode22 =new listNode<string>(second2);
 head2->next= pnode22;
 pnode22->next= pnode4;
 pnode4->next= pnode5;

 // 链表1、2相交
 bool bJunction = isListJunction(head1,head2);
 std::cout<< bJunction<<std::endl;

 std::cout<< checkCircle(head1)<<endl;
 std::cout<< checkCircle(head2)<<endl;


 string first3 ="1";
 string second3 ="2";
 string three3 ="3";
 string four3 ="4";
 string five3 ="5";
 string six3 ="6";
 string seven3 ="7";

 // 链表3，有环
 listNode<string>*head3 =new listNode<string>(first3);
 listNode<string>*pnode32 =new listNode<string>(second3);
 head3->next= pnode32;
 listNode<string>*pnode33 =new listNode<string>(three3);
 pnode32->next= pnode33;
 listNode<string>*pnode34 =new listNode<string>(four3);
 pnode33->next= pnode34;
 listNode<string>*pnode35 =new listNode<string>(five3);
 pnode34->next= pnode35;
 listNode<string>*pnode36 =new listNode<string>(six3);
 pnode35->next= pnode36;
 pnode36->next= pnode33;

 cout<<findLoopPort(head3)->val<<endl;
 cout<<getLoopLength(head3)<<endl;

 // 链表4，有环
 listNode<string>*head4 =new listNode<string>(seven3);
 head4->next= pnode32;
 cout<<isListJunction(head3,head4)<<endl;

 cout<<"the length of list3 : "<<getLoopLength(head3)+ getTailLength(head3)<<endl;
 cout<<"the length of list4 : "<<getLoopLength(head4)+ getTailLength(head3)<<endl;
 
 listNode<string>*junctionNode =new listNode<string>;
 cout<<isListJunction(head3,head4,junctionNode)<<endl;
 cout<<"list3 与 list4的交点： "<<junctionNode->val<<endl;
 return0;
}

转载于:https://www.cnblogs.com/xuhj001/p/3389137.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/377664.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

VS 如何修改C++编译标准

VS 如何修改C++编译标准

第一步&#xff0c;打开项目资源管理器的属性页面 第二步&#xff0c;选择配置属性->C/C>语言->C语言标准 第三步&#xff0c;选择合适的标准&#xff0c;一般来说选最新即可
阅读更多...
维吉尼亚密码和一次性密码本_密码学中的一次性密码

维吉尼亚密码和一次性密码本_密码学中的一次性密码

维吉尼亚密码和一次性密码本The One-time Pad cipher is almost similar to the Vernam cipher, as, like the vernam cipher, this cipher technique also encrypts the plain text by working on the binary level of the text. The only difference between the two is that…
阅读更多...
十一、纺织面料下架功能的实现

十一、纺织面料下架功能的实现

一、数据库 数据库仍用yy_textile表&#xff0c;前几篇博文都叙述过这里就不再叙述 在fiber_yy数据库下创建yy_textile表 初始数据库信息 二、页面 admin_undercarriage 三、代码实现 admin_undercarriage using System; using System.IO; using System.Data; using S…
阅读更多...
svg和canvas的应用场景分析【转载】

svg和canvas的应用场景分析【转载】

原文地址&#xff1a;http://blogs.msdn.com/b/weizhong/archive/2011/07/16/canvas-svg.aspx 思考什么时候使用Canvas 和SVG wzhong 15 Jul 2011 9:07 PM 0HTML5 Canvas 和 SVG 是 IE9 中引入的两项令人激动的图形功能。上周在拉斯维加斯举办的 MIX11 大会对这两个功能进行了介…
阅读更多...
【C++grammar】文件系统以及path类使用

【C++grammar】文件系统以及path类使用

目录1.文件系统概述1、关于路径2、如何将某个路径下的所有文件递归地找出来&#xff1f;2.路径类及操作1、path类的成员函数2、path类的非成员函数示例1&#xff1a;展示C17中的path对象的用法示例2&#xff1a;展示Path类中用于分解路径成分的函数示例3&#xff1a;展示path相…
阅读更多...
scala hashmap_如何在Scala中将Hashmap转换为Map？

scala hashmap_如何在Scala中将Hashmap转换为Map？

scala hashmapLets first understand what are maps and hashmaps? 首先让我们了解什么是map和hashmap &#xff1f; map in Scala is a collection that stores its elements as key-value pairs, like a dictionary. Scala中的map是一个集合&#xff0c;将其元素存储为键值…
阅读更多...
十二、所有功能实现效果演示

十二、所有功能实现效果演示

一、系统项目架构 Ⅰ&#xff0c;fiber_yy数据库下有五张表 yy_admin&#xff1a;管理员登录账号和密码 yy_textile&#xff1a;纺织面料数据信息 yy_textile_record&#xff1a;用户购买纺织面料信息所存储的面料流水信息 yy_user&#xff1a;用户登录注册信息 yy_user_reco…
阅读更多...
行业软件之PTV微观软件VISSIM4.3 5.0 5.1 5.2 5.3 5.4下载和相关资料

行业软件之PTV微观软件VISSIM4.3 5.0 5.1 5.2 5.3 5.4下载和相关资料

他是干什么的&#xff1a;http://baike.baidu.com/view/3656765.htm 中国代理销售的公司的网址&#xff1a;辟途威交通科技(上海)有限公司 官网&#xff1a;http://www.ptvchina.cn/ 看看视频中软件的运行效果&#xff1a;http://v.youku.com/v_show/id_XMzExMjg1MDEy.html 如何…
阅读更多...
一、单个神经元网络构建

一、单个神经元网络构建

一、本人使用编译器为Jupyter Notebook&#xff0c;tensorflow版本为1.13.1 import tensorflow as tf print(tf.__version__) """ 1.13.1 """二、训练单个神经元网络 x为-1.0, 0.0, 1.0, 2.0, 3.0, 4.0 y为-3.0, -1.0, 1.0, 3.0, 5.0, 7.0 人用…
阅读更多...
ruby 生成随机字符串_Ruby程序生成随机数

ruby 生成随机字符串_Ruby程序生成随机数

ruby 生成随机字符串产生随机数 (Generating random number) The task is to generate and print random number. 任务是生成并打印随机数。 Generating random numbers means that any number can be provided to you which is not dependent on any pre-specified condition…
阅读更多...
leetcode 322. 零钱兑换 思考分析

leetcode 322. 零钱兑换 思考分析

目录1、题目2、思路分析3、参考链接1、题目 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额&#xff0c;返回 -1。 你可以认为每种硬币的数量是无限的。 提示&#xff1a; 1 …
阅读更多...
linux上的英文字体monospace可以在windows用吗？

linux上的英文字体monospace可以在windows用吗？

linux的字体都是开源的&#xff0c;应该可以官方下载本地下载转载于:https://www.cnblogs.com/52linux/archive/2012/03/14/2396103.html
阅读更多...
Flash Builder 创建CSS

Flash Builder 创建CSS

1.global 选择器将样式应用于所有控件 在 Flash Builder 中创建新MXML 文件并切换到设计模式 属性视图右侧的外观视图可更改外观 Flash Builder 自动创建CSS 文件 CSS 文件有2 个命名空间&#xff1a; s 指 Spark 组件 mx 指 MX 组件 1. Global 与Application 选择器 global …
阅读更多...
ruby打印_Ruby程序打印数字的力量

ruby打印_Ruby程序打印数字的力量

ruby打印Ruby中数字的幂 (Power of a number in Ruby) The task to develop a program that prints power of a number in Ruby programming language. 开发可以用Ruby编程语言打印数字幂的程序的任务。 If we want to calculate the power of a number manually then we have…
阅读更多...
二、训练fashion_mnist数据集

二、训练fashion_mnist数据集

一、加载fashion_mnist数据集 fashion_mnist数据集中数据为28*28大小的10分类衣物数据集 其中训练集60000张&#xff0c;测试集10000张 from tensorflow import keras import tensorflow as tf import matplotlib.pyplot as plt import numpy as npfashion_mnist keras.data…
阅读更多...
jquerymobile 切换页面时候闪烁问题

jquerymobile 切换页面时候闪烁问题

https://github.com/jquery/jquery-mobile/commit/acbec71e29b6acec6cd2087e84e8434fecc0053f 可以修改css好像是个bug -4,9 4,10 * Dual licensed under the MIT (MIT-LICENSE.txt) or GPL (GPL-LICENSE.txt) licenses.*/.spin {--webkit-animation-name: spin;--webkit-an…
阅读更多...
二分法：两个有序数组长度为N，找到第N、N+1大的数

二分法：两个有序数组长度为N，找到第N、N+1大的数

题目 两个有序数组长度为N&#xff0c;找到第N、N1大的数 思路1&#xff1a;双指针&#xff0c;O(N)复杂度 简述思路&#xff1a; 如果当前A指针指向的数组A的内容小于B指针指向的数组B的内容&#xff0c;那么A指针往右移动&#xff0c;然后nums(当前已经遍历过的数字个数)也…
阅读更多...
Javascript -- In

Javascript -- In

http://www.caveofprogramming.com/articles/javascript-2/javascript-in-using-the-in-operator-to-iterate-through-arrays-and-objects/ http://msdn.microsoft.com/en-us/library/ie/9k25hbz2(vvs.94).aspx转载于:https://www.cnblogs.com/daishuguang/p/3392310.html
阅读更多...
三、自动终止训练

三、自动终止训练

有时候&#xff0c;当模型损失函数值预期的效果时&#xff0c;就可以结束训练了&#xff0c;一方面节约时间&#xff0c;另一方面防止过拟合 此时&#xff0c;设置损失函数值小于0.4&#xff0c;训练停止 from tensorflow import keras import tensorflow as tf import matplo…
阅读更多...
矩阵形状| 使用Python的线性代数

矩阵形状| 使用Python的线性代数

Prerequisite: Linear Algebra | Defining a Matrix 先决条件&#xff1a; 线性代数| 定义矩阵 In the python code, we will add two Matrices. We can add two Matrices only and only if both the matrices have the same dimensions. Therefore, knowing the dimensions o…
阅读更多...
最新文章

Copyright @ 2022~2023