源代码--数据结构与算法(Python版)第8章 图

合集下载

数据结构与算法python语言实现

数据结构与算法python语言实现

数据结构与算法python语言实现数据结构,顾名思义,是一种组织数据的方式。

在计算机科学中,数据结构是对计算机中数据的组织、存储和访问的描述,从而使得数据能够更加高效的被利用。

算法则是指一定的计算步骤,用来解决特定类型问题的方法。

结构和算法之间的关系紧密相连,一个好的数据结构可以给出高效的算法实现,而一个好的算法可以在一定的时间内解决大规模问题。

本篇文章主要介绍数据结构与算法在Python语言中的实现。

1. 线性表线性表是一种线性结构,它是多个数据元素按照特定的顺序排列而成,如数组。

Python中列表(list)是一种内置的线性数据结构,支持常见的插入、删除、查找等操作,同时还提供了丰富的方法和函数。

2. 栈栈是一种先进后出(FILO)的结构,只能在表尾进行插入和删除操作。

Python可以用列表(list)模拟栈,列表提供了append()方法作为入栈操作,pop()为出栈操作。

3. 队列队列是一种先进先出(FIFO)的结构,只能在表头和表尾进行插入和删除操作。

在Python中,可以使用collections模块中的deque类实现队列,或者使用列表(list)的pop(0)和append()方法,不过使用deque性能更优。

4. 树树是一种非线性结构,由根节点和若干子树组成。

Python中可以用字典(dictionary)来实现一个树,其中字典的键表示节点,值表示该节点的子节点。

常用的树结构包括二叉树、平衡树等。

5. 图图是一种非线性结构,由若干个节点和它们之间的边组成。

Python中可以使用字典(dictionary)和内置的set类分别表示图的节点和边,或者使用第三方库networkx实现复杂的图算法。

以上仅是数据结构和算法在Python中的简单介绍和实现,还有许多高级数据结构和算法,如哈希表、堆等,可以通过深入学习和实践进一步掌握。

大学计算机基础算法

大学计算机基础算法

《大学计算机基础》 主讲人:赵丕锡教授
8.2.1 什么是数据结构?
例8.5 无序表的顺序查找与有序表的对分查找。
《大学计算机基础》 主讲人:赵丕锡教授
现实世界中存在的一切个体都可以是数据元素。
例如:“春、夏、秋、冬”,可以作为季节的数据元素;
“26、56、65、 73、26、…”,可以作为数值的数据元素;
《大学计算机基础》
第8章 数据结构与算法
程序是什么?
程序=数据结构+算法!
大连民族学院计算机学院 赵丕锡教授
例:某校对100个学生进行奖励,学生信息存在磁盘文件“file.dat”中, 条件是其三门成绩全部在90分以上才能进行奖励,打印出被奖励学生 的学号。
以C语言为例,程序代码如下: #include <stdio.h> Void main() { struct stu /*数据类型*/ { int num; float score[3]; }a[100]; /* 定义变量*/ FILE *fp; Int I,j; fp=fopen(“file.dat”,”r”); /* 打开文件file.dat*/
对操作的描述。即对数据的操作处理步骤。
程序:就是用计算机语言表示的数据结构和算法。 程序设计:用计算机语言编写程序的过程。两个基本步骤: 1、设计数据结构和算法。 2、用一种计算机语言表示出来。
因此,数据结构与算法是程序设计的基础。
《大学计算机基础》 主讲人:赵丕锡教授
8.1 算

8.1.1 算法的基本概念
首先计算区间的中点c=(a+b)/2,然后计算函数在中点c的值f (c),并判断f (c)是否为0。若f(c)=0,则说明c就是所求的根, 求解过程结束;如果f (c)≠0,则根据以下原则将原区间减半:

数据结构与算法python

数据结构与算法python

数据结构与算法pythonPython是一门非常流行的编程语言,它结合了面向对象编程,函数式编程以及命令式编程的优点,使得它成为一门易上手的编程语言。

在Python中,学习数据结构和算法是必不可少的,因为它们可以帮助我们更好地解决问题,构建出高效的软件系统。

数据结构是一种用来组织和存储数据的方法,它可以使用多种不同的数据类型来存储数据。

在Python中,我们可以使用列表、元组、字典等等来创建数据结构。

除此之外,Python还提供了一些高级的数据结构,如Sets、B-trees和Heaps。

这些数据结构有助于我们更快地查找和处理数据。

算法是一种解决问题的方法,它可以提供一种自动化的解决方案,使得解决问题变得更加容易。

在Python中,我们可以使用许多不同的算法来解决问题,例如排序算法、搜索算法和图论算法等等。

掌握这些算法,可以帮助我们更好地处理数据,并创建出更高效和可靠的软件系统。

Python拥有一些非常强大的库,例如NumPy和pandas,可以让我们更容易地使用数据结构和算法来处理数据。

NumPy是一个基于Numpy数组的计算库,它可以让我们更快地处理向量和矩阵;而pandas则是一个高级的Python数据分析库,它可以提供一系列强大的数据结构和算法,可以帮助我们更好地管理和处理数据。

学习数据结构和算法Python是一个非常有趣的机会,它可以帮助我们更好地理解程序的底层原理,并且熟悉Python的数据结构和算法,可以帮助我们创建出更高效的软件系统。

不管是想要在日常的开发中使用,还是想要在高级的机器学习应用中使用,数据结构和算法Python都是一项十分有价值的技能。

八皇后源代码及流程图

八皇后源代码及流程图

目录一需求分析 (1)1.1程序的功能: (1)1.2程序的输入输出要求: (1)二概要设计 (3)2.1程序的主要模块: (3)2.2程序涉及: (3)三详细设计 (3)3.1相关代码及算法 (4)3.1.1 定义相关的数据类型如下:....................... 错误!未定义书签。

3.1.2 主模块类C码算法: (4)3.1.3 画棋盘模块类C码算法 (5)3.1.4 画皇后模块类C码算法: (5)3.1.5 八皇后摆法模块(递归法): (6)3.1.6 初始化模块 (7)3.1.7 输出摆放好的八皇后图形(动态演示): (7)3.2相关流程图 (9)四调试分析 (12)五设计体会 (13)六附录 (13)七参考文献 (17)一需求分析1.1 程序功能:八皇后问题是一个古老而著名的问题。

该问题是十九世纪著名的数学家高斯1850年提出的。

八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子,问有多少种不同的摆法?并找出所有的摆法。

因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。

本程序通过对子函数void qu(int i)的调用,将八皇后的问题关键通过数据结构的思想予以了实现。

虽然题目以及演算看起来都比较复杂,繁琐,但在实际中,只要当一只皇后放入棋盘后,在横与列、斜线上没有另外一只皇后与其冲突,再对皇后的定位进行相关的判断。

即可完成。

如果在这个程序中,我们运用的是非递归的思想,那么将大量使用if等语句,并通过不断的判断,去推出答案,而且这种非递归的思想,大大的增加了程序的时间复杂度。

如果我们使用了数据结构中的算法后,那么程序的时间复杂度,以及相关的代码简化都能取得不错的改进。

这个程序,我运用到了数据结构中的栈、数组,以及树和回溯的方法。

数据结构教程python语言描述电子版

数据结构教程python语言描述电子版

数据结构教程python语言描述电子版1 数据结构教程Python语言描述电子版简介数据结构是计算机科学中的重要基础知识,Python是一门易学易用的编程语言。

将数据结构和Python相结合,可以为初学者提供一种易懂易学的学习方式。

Python常用的数据结构包括列表、元组、字典和集合等。

本教程使用Python语言描述数据结构,旨在帮助读者了解数据结构的基本概念和常用算法,并在实践中提高Python编程能力。

2 列表与元组列表和元组都是Python中常用的数据结构,它们可以存储任意数据类型的元素。

列表和元组的区别在于,列表是可变的,可以通过索引、切片、追加等方式对其进行修改;而元组是不可变的,一旦创建则无法被修改。

列表和元组的基本操作包括创建、访问、添加元素、删除元素等,具体可以参考教程中的示例代码。

3 字典字典是Python中的另一种重要数据结构,它由键值对组成。

字典的键必须是不可变的类型,例如字符串、数字、元组等;值可以是任意类型的对象。

字典常用的操作包括创建、访问、添加键值对、删除键值对等,具体可以参考教程中的示例代码。

4 集合集合是Python中的一种无序不重复的数据集合,可以进行交集、并集、差集等操作。

集合和列表、元组、字典一样,属于可变对象,可以添加、删除元素。

集合的创建、操作也可以参考教程中的示例代码。

5 总结数据结构是计算机科学中的重要基础知识,本教程通过以Python语言描述数据结构的方式,为初学者提供了一种易懂易学的学习方式。

在实践中,通过熟练掌握Python语言和常用数据结构的基本概念和操作,可以提高编程能力,为未来的学习和工作奠定坚实的基础。

数据结构ppt课件完整版

数据结构ppt课件完整版

针对有序数据集合,每次通过中间元素将 待查找区间缩小为之前的一半,直到找到 元素或区间为空。
哈希查找
树形查找
通过哈希函数将数据映射到哈希表中,实 现快速查找。
如二叉搜索树、平衡树等,通过树形结构实 现高效查找。
排序算法分类及实现原理
插入排序
将待排序元素逐个插入到已排序序列中,直到所有元素均插入完毕。
由n(n>=0)个具有相同类型 的数据元素(结点)a1,a2,
...,an组成的有序序列。
同一性
每个元素必须是同一类型的数 据。
有序性
元素之间具有一对一的前驱和 后继关系,即除首尾元素外, 每个元素都有一个前驱和一个 后继。
可变性
线性表的长度可变,即可以插 入或删除元素。
顺序存储结构与链式存储结构比较
定义
用一段连续的存储单元依次存储线性 表的数据元素。
优点
可以随机存取表中任一元素,且存取 时间复杂度为O(1)。
顺序存储结构与链式存储结构比较
• 缺点:插入和删除操作需要移动大量元素,时间 复杂度高;需要预先分配存储空间,容易造成空 间浪费。
顺序存储结构与链式存储结构比较
定义
用一组任意的存储单元存储线性 表的数据元素(这组存储单元可 以是连续的,也可以是不连续的
查找操作
查找指定元素的位置。
遍历操作
访问线性表中的每个元素。
销毁操作
释放线性表占用的存储空间。
03
栈和队列
栈定义及特点
栈(Stack)是一种特殊的线性数据结构,其数据的存 取遵循后进先出(LIFO, Last In First Out)的原则。 栈的特点
具有记忆功能,能保存数据的状态。
栈的基本操作包括入栈(push)、出栈(pop)、查 看栈顶元素(top)等。 只能在栈顶进行数据的插入和删除操作。

(完整版)python学习课件课件

面向对象编程是Python中的重要概念,它允许我们使用类和 对象来设计和实现程序。类是对象的模板或蓝图,而对象是 类的实例。通过定义类和对象,我们可以模拟现实世界中的 各种实体,并为其添加属性和方法。
异常处理
理解异常处理的概念,掌握try-except语句的使用方法。
异常处理是Python中用于处理程序中可能出现的错误或异常情况的一种机制。 try-except语句用于捕获和处理异常,它允许我们定义一个代码块来执行可能引 发异常的代码,并在出现异常时执行另一个代码块来处理该异常。
总结词
Python的起源与特点概述
详细描述
Python是一种高级的、动态类型的编程语言,诞生于1980年代末期。它具有简 单易学、语法简洁、可读性强等特点,广泛应用于Web开发、数据分析、人工 智能等领域。
Python的语法基础
总结词
Python语法规则和基础概念
详细描述
Python的语法规则包括缩进、注释、变量、数据类型等。它采用缩进来表示代 码块,注释使用井号(#)开头,变量名由字母、数字或下划线组成,数据类型包括 整型、浮点型、布尔型等。
安装与配置
介绍如何安装Flask框架,以及如何配 置开发环境,包括虚拟环境的创建和 使用。
请求与响应
介绍如何处理客户端请求和生成服务 器响应,包括获取请求数据、设置响 应内容、处理异常等。
模板引擎的使用
模板引擎介绍
模板继承与布局
介绍常见的模板引擎,如Jinja2、 Mako等,以及它们在Web开发中的 应用场景。
THANKS
感谢观看
的数据分析。
Matplotlib库
Matplotlib是Python中用于绘制图表和图像的库,提 供了多种绘图函数和工具,支持多种图表类型和风格 。

数据结构严蔚敏(全部章节814张PPT)-(课件)

① 集合:结构中的数据元素除了“同属于一个集合” 外,没有其它关系。
② 线性结构:结构中的数据元素之间存在一对一的 关系。
③ 树型结构:结构中的数据元素之间存在一对多的 关系。
④ 图状结构或网状结构:结构中的数据元素之间存 在多对多的关系。
图1-3 四类基本结构图
1.1.3 数据结构的形式定义
数据结构的形式定义是一个二元组: Data-Structure=(D,S)
计算机求解问题的一般步骤
编写解决实际问题的程序的一般过程:
– 如何用数据形式描述问题?—即由问题抽象出一个 适当的数学模型; – 问题所涉及的数据量大小及数据之间的关系; – 如何在计算机中存储数据及体现数据之间的关系? – 处理问题时需要对数据作何种运算? – 所编写的程序的性能是否良好? 上面所列举的问题基本上由数据结构这门课程来回答。
其中:D是数据元素的有限集,S是D上关系的有限集。 例2:设数据逻辑结构B=(K,R)
K={k1, k2, …, k9} R={ <k1, k3>,<k1, k8>,<k2, k3>,<k2, k4>,<k2, k5>,<k3, k9>, <k5, k6>,<k8, k9>,<k9, k7>,<k4, k7>,<k4, k6> } 画出这逻辑结构的图示,并确定那些是起点,那些是终点
<基本操作名>(<参数表>) 初始条件: <初始条件描述> 操作结果: <操作结果描述>
– 初始条件:描述操作执行之前数据结构和参数应 满足的条件;若不满足,则操作失败,返回相应的出 错信息。

数据结构源代码(全)

/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std;Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit #define MAX_SIZE 100typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l);void find_position(Sq &l);void insert(Sq &l);void dele(Sq &l);int main(){Sq l;init(l);create(l);trval(l);find_value(l);find_position(l);insert(l);trval(l);dele(l);trval(l);return 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];if(l.emel ==NULL){cout<<"\t申请空间失败!"<<endl;exit(1);}l.lenth=0;cout<<"\t成功申请空间!该顺序表的长度目前为:"<<l.lenth<<endl; }void create(Sq &l){cout<<"\t请输入你想输入元素的个数:";int x;cin>>x;if((x<1)&&(x>MAX_SIZE)){cout<<"\t你说输入的数不在范围里"<<endl;return;}int i;for(i=0;i<x;i++){cin>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值!"<<endl;}void trval(Sq &l){int i;cout<<"l(";for(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" ";}cout<<")"<<" 该顺序表现在的长度为:"<<l.lenth<<endl;}void find_value(Sq &l){int x,t=0;cout<<"\t请输入你要查找的值:";cin>>x;int i;for(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;cout<<"\t成功找到该元素,它是顺序表的第"<<i+1<<"个元素!"<<endl;}}if(t==0){cout<<"\t无该元素!"<<endl;}}void find_position(Sq &l){int x;cout<<"\t请输入你要查找的位置:";cin>>x;int i;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}for(i=1;i<=l.lenth;i++){if(i==x){cout<<"\t成功找到该元素,该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--){l.emel[i]=l.emel[i-1];}l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置:";cin>>x;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内!"<<endl;return;}for(i=x-1;i<=l.lenth;i++){l.emel[i]=l.emel[i+1];}l.lenth=l.lenth-1;}成功申请空间!该顺序表的长度目前为:0请输入你想输入元素的个数:3852成功赋值!l(8 5 2 ) 该顺序表现在的长度为:3请输入你要查找的值:5成功找到该元素,它是顺序表的第2个元素!请输入你要查找的位置:3成功找到该元素,该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为:4请输入你要删除位置:3l(8 5 10 ) 该顺序表现在的长度为:3--------------------------------Process exited with return value 0Press any key to continue . . .*//*#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL;return head;}void insert(L* head){int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:");scanf("%d",&q->num);q->next=NULL;p->next=q;p=q;}}void print(L* head){L *p;p=head->next;while(p!=NULL){printf("值为:%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点!!!\n");insert(head);printf("成功输入数据!!!\n");print(head);return 0;}*//*线性表的操作#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败!\n");exit(-1);}head->next=NULL;return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数:");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");exit(-1);}printf("请输入值:");scanf("%d",&q->num);q->next=p->next;p->next=q;}}int print(L* head){L *p;int lenth=0;p=head->next;printf("\t\tL(");while(p!=NULL){lenth++;printf("%d ",p->num);p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内!");return -1;}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败!\n");return -1;}printf("\t\t请为新节点输入值:");scanf("%d",&q->num);int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next;p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth){printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth){printf("\t\t输入值不在范围内!");return -1;}L *p,*q;p=head->next;q=head;int i=0;while(p!=NULL){i++;if(i==out){q->next=p->next;}q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth){printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){printf("\t\t输入值不在范围内!");return ;}L *p;p=head->next;int i=0;while(p!=NULL){i++;if(i==finder){printf("\t\t你要找的该位置所对应的值为:%d\n",p->num);}p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点!!!\n");init(head);printf("成功输入数据!!!\n");int len;len=print(head);printf("\t\t该线性表的长度为:%d\n",len);len=insert(head,len);len=print(head);printf("\t\t插入后线性表的长度为:%d\n",len);len=dele(head,len);len=print(head);printf("\t\t删除后该线性表的长度为:%d\n",len);find(head,len);return 0;}*//*顺序表的合并#include<iostream>using namespace std;struct LA{int *pa;int lenth;};struct LB{int *pb;int lenth;};struct LC{int *pc;int lenth;};void mergelist(LA la,LB lb,LC &lc);int main(){int x,y;LA la;LB lb;cout<<"\t\t请给线性表LA和LB指定长度:";cin>>x>>y;la.pa =new int(sizeof(int)*x);lb.pb =new int(sizeof(int)*y);int i;for(i=0;i<x;i++){cout<<"请输入表LA的值:";cin>>la.pa[i];}cout<<endl;la.lenth=x;for(i=0;i<y;i++){cout<<"请输入表LB的值:";cin>>lb.pb[i];}lb.lenth=y;cout<<"LA(";for(i=0;i<x;i++){cout<<la.pa[i]<<" ";}cout<<")"<<endl;cout<<"LB(";for(i=0;i<y;i++){cout<<lb.pb[i]<<" ";}cout<<")"<<endl;LC lc;mergelist(la,lb,lc);return 0;}void mergelist(LA la,LB lb,LC &lc){lc.lenth=la.lenth+lb.lenth;lc.pc=new int(sizeof(int)*lc.lenth);int *pa=la.pa,*pb=lb.pb,*pc=lc.pc;int *pa_last=la.pa+la.lenth-1;int *pb_last=lb.pb+lb.lenth-1;while(pa<=pa_last && pb<=pb_last){if(*pa <= *pb){*pc++=*pa++;}else{*pc++=*pb++;}}while(pa<=pa_last){*pc++=*pa++;}while(pb<=pb_last){*pc++=*pb++;}cout<<"LC(";int i=0;for(i=0;i<lc.lenth;i++){cout<<lc.pc[i]<<" ";}cout<<")"<<endl;}*///栈/*#include<iostream>using namespace std;#include<stdlib.h>#define MAXSIZE 100typedef struct{int *base;int *top;int stacksize;}Sqstack;int Initstack(Sqstack &s);void Push(Sqstack &s,int e);void StackTraverse(Sqstack &s);void Gettop(Sqstack &s);void Pop(Sqstack &s);int main(){Sqstack s;Initstack(s);cout<<"\t\t初始化栈成功!"<<endl;Push(s,2);cout<<"\t\t2入栈成功!"<<endl;Push(s,4);cout<<"\t\t4入栈成功!"<<endl;Push(s,6);cout<<"\t\t6入栈成功!"<<endl;Push(s,8);cout<<"\t\t8入栈成功!"<<endl;cout<<"\n由栈底至栈顶的元素为:";StackTraverse(s);Gettop(s);Pop(s);Gettop(s);return 0;}int Initstack(Sqstack &s){s.base=new int[MAXSIZE];if(s.base==NULL){exit(1);}s.top=s.base;s.stacksize=MAXSIZE;}void Push(Sqstack &s,int e){if(s.top-s.base==s.stacksize){exit(1);}*s.top++=e;}void StackTraverse(Sqstack &s){int *p=s.base,i=0;while(p<s.top){i++;cout<<*p++<<" ";}cout<<"\t\t栈的长度是"<<i<<endl;}void Gettop(Sqstack &s){if(s.base==s.top){exit(1);}cout<<"栈顶元素是:"<<*(s.top-1)<<endl; }void Pop(Sqstack &s){if(s.top==s.base){exit(1);}cout<<"出栈的第一个元素是:";cout<<*--s.top<<" "<<endl;}*///队列例题:/*#include<iostream>#include<stdlib.h>using namespace std;#define MAXQSIZE 100typedef struct{int *base;int front;int rear;}SqQueue;int InitQueue(SqQueue &q);int EnQueue(SqQueue &q,int x);int DeQueue(SqQueue &q);int main(){SqQueue q;InitQueue(q);EnQueue(q,1);EnQueue(q,3);EnQueue(q,5);EnQueue(q,7);DeQueue(q);DeQueue(q);DeQueue(q);DeQueue(q);return 0;}int InitQueue(SqQueue &q){q.base=new int[MAXQSIZE];if(q.base==NULL){exit(1);}q.front=0;q.rear=0;return 0;}int EnQueue(SqQueue &q,int x){if((q.rear+1)%MAXQSIZE==q.front){exit(0);}q.base[q.rear]=x;q.rear=(q.rear+1)%MAXQSIZE;return 0;}int DeQueue(SqQueue &q){if(q.front==q.rear){exit(0);}int x=q.base[q.front];q.front=(q.front+1)%MAXQSIZE;cout<<x<<endl;}*//*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int date;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front; //队头指针Queueptr rear; //队尾指针}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int e);void TrvalQueue(LinkQueue Q);void DeQueue(LinkQueue &Q);int main(){LinkQueue Q;InitQueue(Q);EnQueue(Q,1);cout<<"\t元素1入队成功!"<<endl;EnQueue(Q,3);cout<<"\t元素3入队成功!"<<endl;EnQueue(Q,5);cout<<"\t元素5入队成功!"<<endl;EnQueue(Q,7);cout<<"\t元素7入队成功!"<<endl;cout<<"\t队列的元素分别是:"<<endl;TrvalQueue(Q);cout<<"\t第一个出队的元素是:"<<endl;DeQueue(Q);cout<<"\n\t第一个元素出队完成之后队列中从队头至队尾的元素为:";TrvalQueue(Q);return 0;}int InitQueue(LinkQueue &Q){Q.rear=new Qnode;Q.front=Q.rear;if(Q.front==NULL){exit(0);}Q.front->next=NULL;return 0;}void EnQueue(LinkQueue &Q,int e){Qnode *p=new Qnode;if(!p){exit(1);}p->date=e;p->next=NULL;Q.rear->next=p; //连接Q.rear=p; //修改队尾指针}void TrvalQueue(LinkQueue Q){Qnode *p=Q.front->next;//队头元素while(Q.front!=Q.rear){cout <<p->date<<" ";Q.front=p;p=p->next;}cout<<endl;}void DeQueue(LinkQueue &Q){if(Q.front==Q.rear){return;}Qnode *p=Q.front->next;cout<<"\t"<<p->date<<endl;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;delete p;}}*//*//表达式求值#include<iostream>#include<stdlib.h>#include<stdio.h>using namespace std;#define MAXSIZE 100typedef struct{char *base;char *top;char num;}OPND; //数据栈typedef struct{char *base;char *top;char c;}OPTR; //符号栈int Initstack(OPND &op_n,OPTR &op_t);void Pushstack(OPND &op_n,char ch);void Pushstack(OPTR &op_t,char ch);char Popstack(OPND &op_n,char ch);char Popstack(OPTR &op_t,char ch);char Gettop(OPTR op_t);char Gettop(OPND op_n);int In(char ch);char Precede(char x,char y);char operate(char z,char x,char y);int main(){OPND op_n;OPTR op_t;Initstack(op_n,op_t);Pushstack(op_t,'#');char ch;char p;cin>>ch;while(ch!='#' || Gettop(op_t)!='#'){if(!In(ch)){Pushstack(op_n,ch);cin>>ch;}else{switch( Precede(Gettop(op_t),ch) ){case '<':Pushstack(op_t,ch);cin>>ch;break;case '>':char x,y,z;x=Popstack(op_t,x);y=Popstack(op_n,y);z=Popstack(op_n,z);Pushstack(op_n,operate(z,x,y));break;case '=':p=Popstack(op_t,p);cin>>ch;break;}}}cout<<"\t表达式结果是:"<<Gettop(op_n)<<endl;return 0;}int Initstack(OPND &op_n,OPTR &op_t){op_n.base=new char[MAXSIZE];op_t.base=new char[MAXSIZE];if((op_n.base==NULL) || (op_t.base==NULL)){exit(1);}op_n.top=op_n.base;op_t.top=op_t.base;op_n.num=MAXSIZE;op_t.c=MAXSIZE;return 0;}void Pushstack(OPND &op_n,char ch){if(op_n.top-op_n.base==op_n.num){return;}*op_n.top++=ch;cout<<ch<<" 入数字栈"<<endl;}void Pushstack(OPTR &op_t,char ch){if(op_t.top-op_t.base==op_t.c){return;}*op_t.top++=ch;cout<<ch<<" 入操作符"<<endl;}char Popstack(OPND &op_n,char ch)if(op_n.top==op_n.base){exit(1);}ch=*--op_n.top;cout<<ch<<" 出数字栈"<<endl;return ch;}char Popstack(OPTR &op_t,char ch){if(op_t.top==op_t.base){exit(1);}ch=*--op_t.top;cout<<ch<<" 出字符栈"<<endl;return ch;}char Gettop(OPTR op_t){char x;if(op_t.top==op_t.base){exit(1);}x=*(op_t.top-1);cout<<"得到操作符栈顶"<<x<<endl;return x;}char Gettop(OPND op_n){char x;if(op_n.top==op_n.base){exit(1);}x=*(op_n.top-1);cout<<"得到操作数栈顶"<<x<<endl;return x;}int In(char ch)if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') {return 1;}else{return 0;}}char Precede(char x,char y){if(x=='+' || x=='-'){if(y=='+' || y=='-' || y==')' || y=='#'){return '>';}else{return '<';}}if(x=='*'||x=='/'){if(y=='('){return '<';}else{return '>';}}if(x=='('){if(y==')'){return '=';}else if(y=='+'||y=='-'||y=='*'||y=='/'||y=='('){return '<';}}if(x==')'){if(y!='('){return '>';}}if(x=='#'){if(y=='#'){return '=';}else if(y!=')'){return '<';}}}char operate(char z,char x,char y) {if(x=='+'){return (z-'0') + (y-'0')+48;}if(x=='-'){return (z-'0') - (y-'0')+48;}if(x=='*'){return (z-'0')* (y-'0')+48;}if(x=='/'){return (z-'0')/ (y-'0')+48;}}*//*#include<iostream>using namespace std;int main(){char a[10];char *b[10];char **c[10];return 0;}*//*#include<iostream>using namespace std;char f(char x,char y){return (x-'0') * (y-'0')+48;}int main(){char a='3',b='5';char p=f(a,b);cout<<p<<endl;return 0;}*///数列出队/*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int num;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front;Queueptr rear;}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int x); int DeQueue(LinkQueue &Q,int p); int main(){LinkQueue Q;InitQueue(Q);int x,i,y,num=0,e;cout<<"请输入总人数:";cin>>x;for(i=1;i<=x;i++){EnQueue(Q,i);}cout<<"请输入第几个数淘汰:";cin>>y;{for(i=0;i<y;i++){if(i!=y-1){e=DeQueue(Q,e);EnQueue(Q,e);}else{DeQueue(Q,e);num++;}}if(num==x-1){break;}}e=DeQueue(Q,e);cout<<"最后剩下的是:"<<e<<endl;return 0;}int InitQueue(LinkQueue &Q){Q.front=new Qnode;Q.rear=Q.front;if(Q.front==NULL){exit(1);}Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int x){Qnode *p=new Qnode;if(!p){exit(1);}p->num=x;p->next=NULL;Q.rear->next=p;}int DeQueue(LinkQueue &Q,int e) {Qnode *p;if(Q.rear==Q.front){exit(0);}p=Q.front->next;e=p->num;Q.front->next=p->next;if(Q.rear==p){Q.front=Q.rear;}delete p;return e;}*//*二叉树#include<iostream>#include<stdlib.h>using namespace std;typedef struct BiTNode{char date;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;void CreateBiTree(BiTree &T);int Depth(BiTree T);int NodeCount(BiTree T);int LeavesNodeCount(BiTree T);int PreOrderTraverse(BiTree T);int InOrderTraverse(BiTree T);int PostOrderTraverse(BiTree T); int main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为:"<<Depth(T)<<endl;cout<<"二叉树中结点个数为:"<<NodeCount(T)<<endl;cout<<"二叉树中叶子结点个数为:"<<LeavesNodeCount(T)<<endl;cout<<"先序遍历:";PreOrderTraverse(T);cout<<"\n中序遍历:";InOrderTraverse(T);cout<<"\n后序遍历:";PostOrderTraverse(T);cout<<endl;return 0;}void CreateBiTree(BiTree &T){cout<<"请为该节点赋值:";char ch;cin>>ch;if(ch=='#'){T=NULL;}else{T =new BiTNode;T->date=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int Depth(BiTree T){int m,n;if(T==NULL){return 0;}else{m=Depth(T->lchild);n=Depth(T->rchild);if(m>n){return m+1;}else{return n+1;}}}int NodeCount(BiTree T){if(T==NULL){return 0;}else{return NodeCount(T->lchild)+NodeCount(T->rchild)+1;}}int LeavesNodeCount(BiTree T){if(T==NULL){return 0;}else if(T->lchild==NULL && T->rchild==NULL){return 1;}else{return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);}}int PreOrderTraverse(BiTree T){if(T!=NULL){cout<<T->date;PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}int InOrderTraverse(BiTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date;InOrderTraverse(T->rchild);}}int PostOrderTraverse(BiTree T){if(T!=NULL){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);cout<<T->date;}}请为该节点赋值:-请为该节点赋值:+请为该节点赋值:a请为该节点赋值:#请为该节点赋值:#请为该节点赋值:*请为该节点赋值:b请为该节点赋值:#请为该节点赋值:#请为该节点赋值:-请为该节点赋值:c请为该节点赋值:#请为该节点赋值:#请为该节点赋值:d请为该节点赋值:#请为该节点赋值:#请为该节点赋值:/请为该节点赋值:e请为该节点赋值:#请为该节点赋值:#请为该节点赋值:f请为该节点赋值:#请为该节点赋值:#二叉树的深度为:5二叉树中结点个数为:11二叉树中叶子结点个数为:6先序遍历:-+a*b-cd/ef中序遍历:a+b*c-d-e/f后序遍历:abcd-*+ef/-Process returned 0 (0x0) execution time : 76.214 s Press any key to continue.*//*#include<iostream>#include<stdlib.h>#include<string.h>using namespace std;typedef struct{int weiget;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char** HuffmanCode;void creat(HuffmanTree &HT,int n);void Select(HuffmanTree HT,int k,int &min1,int &min2); void creatcode(HuffmanTree HT,HuffmanCode &HC,int n); int min(HuffmanTree HT,int k);int main(){int n;cout<<"请输入叶子节点的个数:";cin>>n;HuffmanTree HT;creat(HT,n);HuffmanCode HC;creatcode(HT,HC,n);return 0;}void creat(HuffmanTree &HT,int n){if(n<1){exit(1);}int m=2*n-1,i;HT=new HTNode[m+1];for( i=1;i<=m;i++){HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(i=1;i<=n;i++){cout<<"请输入权值:";cin>>HT[i].weiget;}int s1,s2;for(i=n+1;i<=m;i++) //通过n-1次选择来合并创建{Select(HT,i-1,s1,s2);HT[s1].parent=i; //赋值,作为删除的标记HT[s2].parent=i;cout<<"s1:"<<s1<<" s2:"<<s2<<endl;HT[i].lchild=s1; //生成新节点HT[i].rchild=s2;HT[i].weiget=HT[s1].weiget+HT[s2].weiget;}}void Select(HuffmanTree HT,int k,int &min1,int &min2){min1=min(HT,k);min2=min(HT,k);}int min(HuffmanTree HT,int k){int i=0;int min;//存放weight最小且parent为-1的元素的序号int min_wei;//存放权值while(HT[i].parent!=0){i++;}min_wei=HT[i].weiget;min=i;for(;i<=k;i++){if(HT[i].weiget<min_wei && HT[i].parent==0){min_wei=HT[i].weiget;min=i;}}HT[min].parent=1;return min;}void creatcode(HuffmanTree HT,HuffmanCode &HC,int n){HC =new char *[n+1];char *cd=new char[n];cd[n-1]='\0';int i,start;//start指向最后,即编码结束符的位置int current,father;for(i=1;i<=n;i++){start=n-1;current=i;father=HT[i].parent;while(father!=0){--start;if(HT[father].lchild==current){cd[start]='0';}else{cd[start]='1';}current=father;father=HT[father].parent;}HC[i]=new char[n-start];strcpy(HC[i],&cd[start]);cout<<HT[i].weiget<<"对应的编码是:"<<HC[i]<<endl;}delete cd;}请输入叶子节点的个数:5请输入权值:1请输入权值:2请输入权值:3请输入权值:4请输入权值:5s1:1 s2:2s1:3 s2:6s1:4 s2:5s1:7 s2:81对应的编码是:0102对应的编码是:0113对应的编码是:004对应的编码是:105对应的编码是:11Process returned 0 (0x0) execution time : 4.003 s Press any key to continue.*///折半查找#include<iostream>#include<stdio.h>using namespace std;#define ENDFLAG 10000typedef int KeyType;typedef char* InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SSTable;void CreateSTable(SSTable &ST,int n){int i;ST.R=new ElemType[n+1];for(i=1;i<=n;i++){cout<<"请输入"<<i<<"个测试数据:";cin>>ST.R[i].key;}ST.length=n;}int Search_Bin1(SSTable ST,KeyType key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){high=mid-1;}else{low=mid+1;}}return 0;}int Search_Bin2(SSTable ST,int low,int high,KeyType key) {int mid;if(low>high){return 0;}mid=(low+high)/2;printf("%d+++++",key==ST.R[mid].key);if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){return Search_Bin2(ST,low,mid-1,key);}else{return Search_Bin2(ST,mid+1,high,key);}}int main(){int n;KeyType key;SSTable ST;cout<<"请输入静态查找表长:";cin>>n;CreateSTable(ST,n);cout<<"请输入待查记录的关键字:";cin>>key;cout<<"Search_Bin1算法计算的位置为:"<<Search_Bin1(ST,key)<<endl;cout<<"Search_Bin2算法计算的位置为:"<<Search_Bin2(ST,1,ST.length,key)<<endl;return 0;}/*请输入静态查找表长:5请输入1个测试数据:1请输入2个测试数据:2请输入3个测试数据:3请输入4个测试数据:4请输入5个测试数据:5请输入待查记录的关键字:3Search_Bin1算法计算的位置为:3Search_Bin2算法计算的位置为:3Process returned 0 (0x0) execution time : 8.620 sPress any key to continue.*//*#include<iostream>using namespace std;typedef struct{int key;}ElemType;typedef struct BSTNode{ElemType date;struct BSTNode *lchild,*rchild;}BSTNode,*BSTree;void Create(BSTree &T);void Insert(BSTree &T,ElemType e);int InOrderTraverse(BSTree T);int main(){BSTree T;Create(T);InOrderTraverse(T);cout<<"\n中序遍历:";return 0;}void Create(BSTree &T){T=NULL;ElemType e;cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;while(e.key!=0){Insert(T,e);cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;}}void Insert(BSTree &T,ElemType e){if(!T){BSTree S;S=new BSTNode;S->date=e;S->lchild=NULL;S->rchild=NULL;T=S;}else if(e.key<T->date.key){Insert(T->lchild,e);}else{Insert(T->rchild,e);}}int InOrderTraverse(BSTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date.key<<" ";InOrderTraverse(T->rchild);}return 0;}请为节点赋值:(0为结束条件)12请为节点赋值:(0为结束条件)7请为节点赋值:(0为结束条件)17请为节点赋值:(0为结束条件)11请为节点赋值:(0为结束条件)16请为节点赋值:(0为结束条件)2请为节点赋值:(0为结束条件)13请为节点赋值:(0为结束条件)9请为节点赋值:(0为结束条件)21请为节点赋值:(0为结束条件)4请为节点赋值:(0为结束条件)02 4 7 9 11 12 13 16 17 21中序遍历:Process returned 0 (0x0) execution time : 23.808 s Press any key to continue.*/。

Python中常用的数据结构和算法

Python中常用的数据结构和算法Python是一种高级编程语言,具有简单易学、语法简洁、运行速度快等优点,广泛应用于各个领域。

在Python中,数据结构和算法是非常重要的基础知识。

本文将介绍Python中常用的数据结构和算法。

一、数据结构1.列表列表是Python中最常用的数据结构之一。

它是一个有序的集合,可以包含任意类型的数据。

列表中的元素可以通过下标来访问,如下所示:lst = [1, 2, 3, 'hello', 'world']print(lst[1]) #输出2print(lst[-1]) #输出'world'2.元组元组是Python中另一个常用的数据结构,与列表相比,元组是不可变的。

元组通常用于存储一些不可修改的数据,如坐标等。

元组可以通过下标来访问,如下所示:tup = (1, 2, 3, 'hello', 'world')print(tup[1]) #输出2print(tup[-1]) #输出'world'3.字典字典是Python中非常有用的数据结构,它是由一组键/值对组成的无序集合。

字典中的键必须是不可变类型,如字符串、数字或元组等,而值可以是任意类型的数据。

字典的访问方式与列表和元组不同,需要通过键来访问相应的值,如下所示:dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}print(dict['name']) #输出Tom4.集合集合是Python中另一个常用的数据结构,它是由一组不重复的元素组成的无序集合。

集合支持并、交、差等操作,如下所示:set_a = {1, 2, 3, 4}set_b = {3, 4, 5, 6}print(set_a | set_b) #输出{1, 2, 3, 4, 5, 6}print(set_a & set_b) #输出{3, 4}print(set_a - set_b) #输出{1, 2}二、算法1.排序算法排序是一种常用的算法,它将一个序列按照指定的规则进行排序。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

目录第8章图 (2)图的邻接矩阵举例 (2)图的邻接表举例 (5)8.3 图的遍历 (6)8.3.1 深度优先遍历 (7)8.3.2 广度优先遍历 (8)8.4 最小生成树 (9)8.4.1 克鲁斯卡尔(Kruskal)算法 (9)8.4.2 普里姆(Prim)算法 (12)8.5 最短路径 (14)14168.617 (17)18第8章图图的邻接矩阵举例import networkx as nx #调用networkximport matplotlib.pyplot as plt #调用matplotlib,绘制图class Graph_Matrix: #邻接矩阵Adjacency Matrixdef __init__(self, vertices=[], matrix=[]):self.matrix = matrixself.edges_dict = {} # {(tail, head):weight}self.edges_array = [] # (tail, head, weight)self.vertices = verticesself.num_edges = 0if len(matrix) > 0: #创建边的列表if len(vertices) != len(matrix):raise IndexErrorself.edges = self.getAllEdges()self.num_edges = len(self.edges)elif len(vertices) > 0: #节点列表self.matrix = [[0 for col in range(len(vertices))] for row in range(len(vertices))] self.num_vertices = len(self.matrix)def isOutRange(self, x): #越界try:if x >= self.num_vertices or x <= 0:raise IndexErrorexcept IndexError:print("节点下标出界")def isEmpty(self): #是否为空if self.num_vertices == 0:self.num_vertices = len(self.matrix)return self.num_vertices == 0def add_vertex(self, key): #添加结点if key not in self.vertices:self.vertices[key] = len(self.vertices) + 1# 添加一个节点意味着添加行和列, 对每一行都添加一列for i in range(self.getVerticesNumbers()):self.matrix[i].append(0)self.num_vertices += 1nRow = [0] * self.num_verticesself.matrix.append(nRow)def getVertex(self, key): #返回节点passdef add_edges_from_list(self, edges_list): # 边列表: [(tail, head, weight),()]for i in range(len(edges_list)):self.add_edge(edges_list[i][0], edges_list[i][1], edges_list[i][2], )def add_edge(self, tail, head, cost=0): #添加边if tail not in self.vertices:self.add_vertex(tail)if head not in self.vertices:self.add_vertex(head)self.matrix[self.vertices.index(tail)][self.vertices.index(head)] = costself.edges_dict[(tail, head)] = costself.edges_array.append((tail, head, cost))self.num_edges = len(self.edges_dict)def getEdges(self, V): # 返回边passdef getVerticesNumbers(self): #返回节点数目if self.num_vertices == 0:self.num_vertices = len(self.matrix)return self.num_verticesdef getAllVertices(self): #返回所有的节点return self.verticesdef getAllEdges(self): #返回所有的边for i in range(len(self.matrix)):for j in range(len(self.matrix)):if 0 < self.matrix[i][j] < float('inf'):self.edges_dict[self.vertices[i], self.vertices[j]] = self.matrix[i][j]self.edges_array.append([self.vertices[i], self.vertices[j], self.matrix[i][j]]) return self.edges_arraydef __repr__(self):return str(''.join(str(i) for i in self.matrix))def to_do_vertex(self, i):print('vertex: %s' % (self.vertices[i]))def to_do_edge(self, w, k):print('edge tail: %s, edge head: %s, weight: %s' % (self.vertices[w], self.vertices[k], str(self.matrix[w][k])))def create_undirected_matrix(my_graph):nodes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']matrix = [[0, 1, 1, 1, 1, 1, 0, 0], # a[0, 0, 1, 0, 1, 0, 0, 0], # b[0, 0, 0, 1, 0, 0, 0, 0], # c[0, 0, 0, 0, 1, 0, 0, 0], # d[0, 0, 0, 0, 0, 1, 0, 0], # e[0, 0, 1, 0, 0, 0, 1, 1], # f[0, 0, 0, 0, 0, 1, 0, 1], # g[0, 0, 0, 0, 0, 1, 1, 0]] # hmy_graph = Graph_Matrix(nodes, matrix)print(my_graph)return my_graphdef draw_undircted_graph(my_graph):G = nx.Graph() # 建立一个空的无向图Gfor node in my_graph.vertices: #添加节点G.add_node(str(node))for edge in my_graph.edges: #添加边G.add_edge(str(edge[0]), str(edge[1]))print("nodes:", G.nodes()) # 输出全部的节点print("edges:", G.edges()) # 输出全部的边print("number of edges:", G.number_of_edges()) # 输出边的数量nx.draw(G, with_labels=True)plt.savefig("undirected_graph.png")plt.show()if __name__=='__main__':my_graph = Graph_Matrix()create_graph=create_undirected_matrix(my_graph)draw_undircted_graph(create_graph)【程序运行结果如下所示】[0, 1, 1, 1, 1, 1, 0, 0][0, 0, 1, 0, 1, 0, 0, 0][0, 0, 0, 1, 0, 0, 0, 0][0, 0, 0, 0, 1, 0, 0, 0][0, 0, 0, 0, 0, 1, 0, 0][0, 0, 1, 0, 0, 0, 1, 1][0, 0, 0, 0, 0, 1, 0, 1][0, 0, 0, 0, 0, 1, 1, 0]nodes: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']edges: [('a', 'b'), ('a', 'c'), ('a', 'd'), ('a', 'e'), ('a', 'f'), ('b', 'c'), ('b', 'e'), ('c', 'd'), ('c', 'f'), ('d', 'e'), ('e', 'f'), ('f', 'g'), ('f', 'h'), ('g', 'h')]number of edges: 14程序运行如图8.5所示。

相关文档
最新文档