数据结构图基本算代码
数据结构-队列基本运算的实现及其应用
数据结构-队列基本运算的实现及其应用篇一数据结构-队列基本运算的实现及其应用一、队列的基本概念队列是一种特殊的数据结构,它遵循先进先出(FIFO)的原则,即先进入队列的元素先出队列。
在队列中,新元素被添加到队列的末尾,而删除操作总是发生在队列的开头。
队列常用于解决各种问题,如处理事件、任务调度、缓冲处理等。
二、队列的基本操作队列的基本操作包括入队(enqueue)、出队(dequeue)、查看队首元素(peek)和判断队列是否为空。
入队操作:向队列的末尾添加一个新元素。
这个操作的时间复杂度通常为O(1),可以通过在队列的末尾添加元素来实现。
出队操作:删除队列开头的元素并返回它。
这个操作的时间复杂度通常为O(1),可以通过移除队列开头的元素来实现。
查看队首元素:返回队列开头的元素但不删除它。
这个操作的时间复杂度通常为O(1),可以通过返回队列开头的元素来实现。
判断队列是否为空:检查队列是否包含任何元素。
这个操作的时间复杂度通常为O(1),可以通过比较队列的长度和0来实现。
三、队列的实现队列可以通过不同的数据结构来实现,如数组、链表和循环列表等。
在这里,我们将介绍使用数组和链表来实现队列的基本操作。
使用数组实现队列使用数组实现队列时,我们需要保留一个空间来跟踪队列的开头和结尾。
通常,我们使用两个指针,一个指向队列的开头,另一个指向队列的结尾。
当我们在队列中添加一个新元素时,我们将它添加到结尾指针所指向的位置,并将结尾指针向后移动一位。
当我们要删除一个元素时,我们只需将开头指针向后移动一位并返回该位置的元素即可。
使用链表实现队列使用链表实现队列时,我们通常使用一个头指针指向队首元素,一个尾指针指向队尾元素的下一个位置。
入队操作时,我们在尾指针的位置创建一个新节点,并将尾指针移动到下一个位置。
出队操作时,我们只需删除头指针指向的节点,并将头指针移动到下一个位置。
四、队列的应用队列在计算机科学中有着广泛的应用,下面列举几个常见的例子:事件处理:在多线程编程中,队列经常用于事件驱动的系统来传递事件或消息。
数据结构-实验报告顺序表基本运算
(封面)学生实验报告学院:国际经贸学院课程名称:数据结构专业班级:09电子商务姓名:学号:学生实验报告(经管类专业用)一、实验目的及要求:1、目的通过实验,实现顺序表的各种基本运算。
2、内容及要求编写一个程序,实现顺序表的各种基本运算,并在此基础上设计一个主程序完成下列功能:(1) 初始化顺序表L(2) 依次采用尾插法插入a,b,c,d,e(3) 输出顺序表L(4) 输出顺序表L长度;(5) 判断顺序表L是否为空;(6) 判断顺序表L 的第3个元素;(7) 输出元素‘a’的位置;(8) 在第4个元素位置上插入‘f’元素;(9) 输出顺序表L(10) 删除L的第3个元素;(11) 输出顺序表L(12) 释放顺序表L二、仪器用具:三、实验方法与步骤:一、查阅顺序表等相关资料,熟悉顺序表基本概念和流程二、“开展”顺序表实验流程三、整理实验数据和文档,总结实验的过程,编写实验报告四、实验结果与数据处理:1、顺序表的代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->data[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->data[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->data[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; //将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置*/ L->data[j]=L->data[j-1];L->data[i]=e;L->length++; //顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; //将顺序表位序转化为elem下标*/e=L->data[i];for (j=i;j<L->length-1;j++)L->data[j]=L->data[j+1];L->length--;return 1;}void main(){SqList *L;ElemType e;printf("(1)初始化顺序表L\n");InitList(L);printf("(2)依次采用尾插法插入a,b,c,d,e元素\n"); ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf("(3)输出顺序表L:");DispList(L);printf("(4)顺序表L长度=%d\n",ListLength(L));printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空")); GetElem(L,3,e);printf("(6)顺序表L的第3个元素=%c\n",e);printf("(7)元素a的位置=%d\n",LocateElem(L,'a'));printf("(8)在第4个元素位置上插入f元素\n");ListInsert(L,4,'f');printf("(9)输出顺序表L:");DispList(L);printf("(10)删除L的第3个元素\n");ListDelete(L,3,e);printf("(11)输出顺序表L:");DispList(L);printf("(12)释放顺序表L\n");DestroyList(L);}2、实验流程及截图:五、讨论与结论在实验的过程中,需要注意以下几点:首先,实验操作者要注意掌握:顺序表等概念。
源代码--数据结构与算法(Python版)chap10 排序
交换类
(2)快速排序 快速排序采用分而治之(Divide and Conquer)
的策略将问题分解成若干个较小的子问题,采用 相同的方法一一解决后,再将子问题的结果整合 成最终答案。快速排序的每一轮处理其实就是将 这一的基准数定位,直到所有的数都排序完成 为止。
21
快速排序的基本步骤:
1. 选定一个基准值(通常可选第一个元素); 2. 将比基准值小的数值移到基准值左边,形
14
• 交换类
交换类排序的基本思想是:通过交换无序序列 中的记录得到其中关键字最小或最大的记录,并将 其加入到有序子序列中,最终形成有序序列。交换 类排序可分为冒泡排序和快速排序等。
15
交换类
(1)冒泡排序 两两比较待排序记录的关键字,发现两
个记录的次序相反时即进行交换,直到没有 反序的记录为止。因为元素会经由交换慢慢 浮到序列顶端,故称之为冒泡排序。
3. 最后对这个组进行插入排序。步长的选法 一般为 d1 约为 n/2,d2 为 d1 /2, d3 为 d2/2 ,…, di = 1。
11
【例】给定序列(11,9,84,32,92,26,58,91,35, 27,46,28,75,29,37,12 ),步长设为d1 =5、d2 =3、 d3 =1,希尔排序过程如下:
for i in range(1,len(alist)):
#外循环n-1
for j in range(i,0,-1):
#内循环
if alist[j]<alist[j-1]:
alist[j],alist[j-1]=alist[j-1],alist[j] #交换
li=[59,12,77,64,72,69,46,89,31,9] print('before: ',li) insert_sort(li) print('after: ',li)
完整word版清华严蔚敏数据结构的全部代码实现C语言word文档良心出品
/*c1.h(程序名 ) */#include<string.h> #include<ctype.h>#include <malloc .h> /* malloc() 等 */ #include <limits.h> /* INT _MAX 等 */#include <stdio.h> /* EOF(=^Z 或 F6),NULL */ #include<stdlib.h> /* atoi() */ #include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */ #include<process.h> /* exit() */ /* 函数结果状态代码 */ #define TRUE 1 #define #define #define /*#define OVERFLOW -2 因为在 math.h 中已定义 OVERFLOW 的值为3,故去掉此行 */ typedef int Status; /* Status 是函数的类型 ,其值是函数结果状态代码,如 OK 等 */ typedef int Boolean; /* Boolean 是布尔类型,其值是 TRUE 或 FALSE */FALSE 0 OK 1 #define ERROR 0 INFEASIBLE -1/* algo2-1.c 实现算法 2.1 的程序*/#include"c1.h" typedef intElemType ;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2 /* 线性表存储空间的分配增量*/ typedef struct {ElemType *elem ; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /*当前分配的存储容量(以sizeof(ElemType)为单位)*/}SqList;#include "bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h 定义)的基本操作(12 个) */ Status InitList (SqList *L ) /* 算法 2.3 */ { /* 操作结果:构造一个空的顺序线性表*/(*L ).elem=(ElemType*) malloc ( LIST_INIT_SIZE *sizeof(ElemType)); if(!( *L ).elem)exit (OVERFLOW); /* 存储分配失败*/ (*L ).length=0; /* 空表长度为0 */ (*L ).listsize =LIST_INIT_SIZE ; /* 初始存储容量return OK;}*/Status DestroyList (SqList *L ){ /* 初始条件:顺序线性表L 已存在。
数据结构实验报告实现单链表各种基本运算的算法
实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。
数据与数据结构
数据与数据结构数据与数据结构⒈数据的定义与分类⑴数据的概念数据是指以符号形式记录的信息的集合,是对客观事物的描述或表达。
数据包括数值型数据、字符型数据、逻辑型数据等。
⑵数据的分类数据可以根据不同的特征进行分类,常见的分类方式有:●按数据的性质:数值型数据、字符型数据、逻辑型数据等。
●按数据的来源:原始数据、二手数据、模拟数据、数字数据等。
●按数据的结构:线性数据、非线性数据、简单数据、复杂数据等。
⒉数据结构的概念与基本操作⑴数据结构的概念数据结构是指数据对象中数据元素之间的关系以及这些关系的操作规则的集合。
数据结构可以分为线性结构、非线性结构、集合结构和图结构等。
⑵数据结构的基本操作数据结构的基本操作包括插入、删除、查找、修改等。
常见的基本操作有:●插入:将一个新元素插入到已有数据结构中的合适位置。
●删除:将已有数据结构中的某个元素删除。
●查找:在已有数据结构中查找指定元素。
●修改:对已有数据结构中的元素进行修改。
⒊数组⑴数组的概念与特点数组是一种线性数据结构,它由一组连续的存储单元组成,用于存储相同类型的数据。
数组具有以下特点:●元素类型必须相同。
●内存空间连续。
●大小固定。
⑵数组的基本操作数组的基本操作包括访问、插入、删除等。
常见的操作有:●访问:通过下标访问数组中的元素。
●插入:将一个新元素插入到数组中的指定位置。
●删除:删除数组中指定位置的元素。
⒋链表⑴链表的概念与特点链表是一种非连续的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的引用。
链表具有以下特点:●内存空间不连续。
●节点通过引用进行连接。
●大小可以动态改变。
⑵链表的基本操作链表的基本操作包括插入、删除、查找等。
常见的操作有:●插入:将一个新节点插入到链表中的合适位置。
●删除:从链表中删除某个节点。
●查找:在链表中查找指定节点。
⒌栈与队列⑴栈的概念与特点栈是一种先进后出(LIFO)的线性数据结构,它只允许在栈的一端进行插入和删除操作。
数据结构经典代码(严蔚敏)
/* 线性表的顺序表示:类型和界面定义*//* 线性表的顺序表示:函数实现*//* 线性表的单链表表示:类型和界面函数定义*//* 线性表的单链表表示:函数实现*//* 线性表的顺序表示:类型和界面定义*//* 线性表的顺序表示:函数实现*//* 用顺序表解决josephus问题的算法*//* 用循环单链表解决josephus问题的算法*//*字符串的顺序表示*//* 字符串的链接表示 *//* 顺序栈表示:类型和界面函数声明 *//* 顺序栈表示:函数定义 *//* 栈链接表示:类型和界面函数声明 *//*栈链接表示:函数定义*//* 简化背包问题的递归算法*//* 简化背包问题的非递归算法*//* 迷宫问题的递归算法*//* 迷宫问题的非递归算法(栈实现)*//* 队列的顺序表示:类型和函数声明 *//* 队列的顺序表示:函数定义 *//*队列链接表示:类型和界面函数声明*//*队列链接表示:函数定义*//* 用队列解决农夫过河问题的算法*//* 树的长子-兄弟表示法*//* 树的父指针表示法*//* 树的子表表示法*//* 树的后根周游的递归算法*//* 树的先根周游的非递归算法*//* 树的中根周游的递归算法*//* 树的后根周游的递归算法*//* 树的广度优先周游算法*//* 二叉树的链接表示*//* 二叉树的顺序表示*//* 线索二叉树的定义,构造算法和中根周游算法*//* 二叉树前根周游的递归算法*//* 二叉树对称根周游的递归算法*//* 二叉树后根周游的递归算法*//* 二叉树后根周游的非递归算法*//* 本程序提供了用顺序表实现字典的存储表示定义*//* 本程序是用开地址法解决碰撞的散列表示方法,提供了字典的一些基本操作*//* 字典的二叉排序树实现,本程序实现了二叉排序树的基本操作的算法*/ /* 字典的AVL树实现*//* 本程序提供了用顺序表实现字典的情况下的顺序检索算法*//* 本程序提供了用顺序表实现字典的情况下的二分法检索算法*//* 本程序是用开地址法实现散列的检索算法*//* 二叉排序树的检索算法*//* AVL树的检索算法*//* 最佳二叉排序树是具有最佳检索效率的二叉排序树, 本程序提供了最佳二叉排序树的构造方法*//* 直接插入排序的算法源程序*//* 二分法插入排序的算法源程序*//* 表插入排序的算法源程序*//* shell排序的算法源程序 *//* 直接选择排序的算法源程序*//* 堆排序的算法源程序*//* 起泡排序的算法源程序*//* 快速排序的算法源程序*//* 基数排序的算法源程序*//* 二路归并排序算法的源程序*//* 用图邻接矩阵表示实现的一些基本运算*//* 用图邻接表表示实现的一些基本运算*//* 用邻接矩阵表示的图的广度优先周游算法*//* 用邻接表表示的图的广度优先周游算法*//* 用邻接矩阵表示的图的深度优先周游的递归算法*/ /* 用邻接矩阵表示的图的深度优先周游的非递归算法*/ /* 用邻接表表示的图的深度优先周游的非递归算法*/ /* 用邻接矩阵表示的图的Kruskal算法的源程序*//* 用邻接矩阵表示的图的prim算法的源程序*//* 用邻接矩阵表示的图的Dijkstra算法的源程序*//* 用邻接矩阵表示的图的Floyd算法的源程序*//* 用邻接表表示图的拓扑排序算法*//* 用邻接矩阵表示图的拓扑排序算法*//* 图的关键路径问题的算法*//* 背包问题的贪心法算法*//* 用动态规划法求组和数的算法*//* 用回溯法解决骑士周游问题的算法*//* 0/1背包问题的回溯法算法*//* 0/1背包问题的动态规划法算法*//* 0/1背包问题的分支定界法算法*//* 线性表的顺序表示:类型和界面定义*/#define TRUE 1#define FALSE 0#define SPECIAL -1/* 定义顺序表的大小。
《python培训》数据结构PPT课件
掌握数据结构,是进行高级编程和算法分析的基础。了解数据结构能够帮助 你更高效地解决问题,并编写出更优秀的代码。
什么是数据结构?
抽象数据结构
数据对象以及在该对象上定义的操作。
内部数据表示
数据和下标之间的关系的物理表示。
数据操作
对数据对象定义的操作的实现。
数据类型
查找节点
顺序查找,时间复杂度为O(n)。
常见数据结构:栈与队列
栈
一种操作受限的线性结构,特点是后进先出。
队列
一种操作受限的线性结构,特点是先进先出。
栈操作(进出栈)
进栈
接受一个元素,放到栈顶。
出栈
把栈顶元素移除,并返回它。
队列操作(进出队列)
进队列
把元素加入队列尾部。
出队列
从队列头部删除元素,并返回该元素。
一种数据对象及其相关操作。
数据结构分类
线性结构
数组 链表 栈 队列
非线性结构
树 图
算法与数据结构
1
算法
一组执行特定任务的有序操作。
2
数据结构
组织数据的不法时间复杂度来衡量算法的效率。
常见数据结构:数组
1 定义
一种线性结构,内存上连续存储。
3 优点
随机存储,寻址速度快。
常见数据结构:树
二叉树
每个节点最多有两个子节点。
二叉搜索树
二叉树的一种,按照左小右大 的规则建树。
平衡二叉树
一种特殊的二叉搜索树,任意 节点的左右子树高度差不超过1。
树的遍历
DFS
深度优先搜索,分为前序遍历、中序遍历、后序遍 历。
BFS
广度优先搜索,按层次访问。
数据结构与算法实验源代码
数据结构与算法实验源代码数据结构与算法实验源代码一、实验目的本实验旨在通过编写数据结构与算法的实验源代码,加深对数据结构与算法的理解,并提高编程能力。
二、实验环境本实验使用以下环境进行开发和测试:- 操作系统:Windows 10- 开发工具:IDEA(集成开发环境)- 编程语言:Java三、实验内容本实验包括以下章节:3.1 链表在本章节中,我们将实现链表数据结构,并实现基本的链表操作,包括插入节点、删除节点、查找节点等。
3.2 栈和队列在本章节中,我们将实现栈和队列数据结构,并实现栈和队列的基本操作,包括入栈、出栈、入队、出队等。
3.3 树在本章节中,我们将实现二叉树数据结构,并实现二叉树的基本操作,包括遍历树、搜索节点等。
3.4 图在本章节中,我们将实现图数据结构,并实现图的基本操作,包括广度优先搜索、深度优先搜索等。
3.5 排序算法在本章节中,我们将实现各种排序算法,包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
3.6 搜索算法在本章节中,我们将实现各种搜索算法,包括线性搜索、二分搜索、广度优先搜索、深度优先搜索等。
四、附件本文档附带实验源代码,包括实现数据结构和算法的Java源文件。
五、法律名词及注释5.1 数据结构(Data Structure):是指数据对象中数据元素之间的关系。
包括线性结构、树形结构、图形结构等。
5.2 算法(Algorithm):是指解决问题的一系列步骤或操作。
算法应满足正确性、可读性、健壮性、高效性等特点。
5.3 链表(Linked List):是一种常见的数据结构,由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
5.4 栈(Stack):是一种遵循后进先出(LIFO)原则的有序集合,用于存储和获取数据。
5.5 队列(Queue):是一种遵循先进先出(FIFO)原则的有序集合,用于存储和获取数据。
5.6 树(Tree):是由节点组成的层级结构,其中一种节点作为根节点,其他节点按照父子关系连接。
数据结构 实验一:实现单链表各种基本运算的算法
- 1 -实验一:实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义;2、 实现单链表各种基本运算的算法。
二、 实验环境1、 Windows 操作系统;2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。
四、 概要设计1.存储结构的类型定义:Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图:3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中,(1)定义单链表结构类型;(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。
数据结构常见算法
int n,*a; cin>>n; a=new int [n]; int i=0,j=n-1; for (i=0;i<n;i++) cin>>a[i]; i=0; while (i<j){
template <class T> void CycleList<T>::append(Node<T> *p) { p->next=rear->next; rear->next=p; rear=p; return; }
数据结构算法
数据结构
• 数据结构是一门研究非数值计算的程序设计问题中的操作 对象(结点)以及它们之间关系和操作等的学科。 • 1968 年克努思教授开创了数据结构的最初体系,他所著
的《计算机程序设计艺术》第一卷《基本算法》是第一本
较系统地阐述数据的逻辑结构和存储结构及其操作的著作。 70 年代初,数据结构作为一门独立的课程开始进入大学
课堂。 • 下面介绍数据结构中常见的一些基本算法
• 关于算法 • 线性表上的常见算法 • 基于队列的常见算法 • 基于栈的常见算法
算法
• 多项式求的两种方法
– A(x)=anxn+an-1xn-1+…+a0
– A(x)=((anx+an-1)X+an-2)…+a0
template<typename T> T Poly1(T a[],int n,T x) { int i,j; T result=0; T xn,xx; for( i=0;i<n;i++) – A(x)=anxn+an-1xn-1+…+a0 { xn=1; xx=x; for(j=0;j<i;j++) xn=xn*xx; result=a[i]*xn+result; } return result; }
《数据结构》课件第一章
程序步确定方法
关于复杂度数量级的表示方法
O(n) O(n) O(n)
C + O(n) C * O(n) O(n) * O(n)
顺序语句 一重循环 多重循环 条件判断
C
n m*n、m*n*l、 m*n*l*t …… Max( u, v) (u和v也可能是常数)
➢对于一个多项式的时间复杂度,只记它最高的幂次。
基本概念和术语(二)
➢ 数据结构:
✓ 结构是指数据间的关系。 ✓ 数据结构是指是相互之间存在某种特定关系的
数据元素的集合。(模型) ✓ 数据结构包括三个方面的内容 ▪ 数据的逻辑结构 ▪ 数据的存储结构 ▪ 数据的运算
一个算法的设计取决于选定的逻辑结构, 算法的实现依赖于采用的存储结构
图书馆查询系统 人机对羿
➢ 算法最坏时间复杂度:算法在任何输入 实例上运行时间的上界。
算法的时间复杂度不仅仅依赖于问题的 规模,还取决于输入实例的初始状态
e.g 折半查找法 最好情况:1(x = n/2) 最坏情况:log2 n 一般来说,在普通应用场合中使用折半查找法 时,以最坏情况时的复杂度作为该算法的复 杂度
算法的空间复杂度分析
算法及算法复杂度分析
什么是数据结构
计算机加工处理的对象由纯粹的数值发展 到字符、图表、图象等各种具有一定结构 的数据。
用计算机解决一个具体问题的时候一般有 几个步骤:
❖ 从具体问题抽象出一个数学模型 ❖ 设计解决这个模型的算法(找到处理的对象
的特性和对象之间的关系) ❖ 编程、测试、得到最终解
良好的抽象思维能力
能够针对算法流程图逐一阐述出算法的 完整实现流程
关于流程图的介绍
每个流程图都有一个开始标记 每个流程图至少有一个结束标记 程序模块的确定——顺序语句 条件分支的画法 如何用“条件分支”来实现“循环”的
【数据结构】线性表顺序表详解和代码实例
【数据结构】线性表顺序表详解和代码实例线性表(List)是零个或者多个数据元素的有限序列.⾸先它是⼀个序列.⾥⾯的元素是有顺序的,如果有多个元素,除开头和结尾以外的元素都有⼀个前驱和⼀个后继.⽽开头元素只有后继,结尾元素只有前驱.其次线性表是有限的,也就是⾥⾯的元素个数是有限的。
1ADT 线性表(List)2Data3线性表的数据对象集合为{a1, a2, a3, ......, an},每个元素类型为DataType。
4Operation5InitList(L); //初始化线性表6 IsEmptyList(L); //判断线性表是否为空7 ClearList(L); //清空线性表8 GetElemList(L, i, *e); //获取第i个位置的数据9 SearchList(L, e); //查找与数据e相等的元素10 InsertNodeList(L, i, e);//在第i个位置插⼊元素11 DeleteNodeList(L, i, *e);//删除第i个位置的元素,e获取删除元素12 GetLengthList(L); //获取线性表的长度13endADT关于线性表的基本操作就上⾯⼏种,还有⼏个例如线性表的排序,合并,逆序等等操作。
为了⽂章篇幅,就下次再介绍了。
线性表的顺序存储结构,就是指 ⽤⼀段地址连续的存储单元⼀次存储线性表的数据元素。
学过⾼级语⾔的朋友,相信对数组这玩意⼉都不会陌⽣吧。
数组就是⼀种顺序存储结构。
链式存储结构就是可以⽤⼀组任意的内存单元存储线性表中的元素。
与顺序存储不同的是,这组内存单元可以是连续的,也可以是不连续的。
这就意味着,元素可以存储在内存的任意位置。
正因为如此,在链式结构中,每个元素不仅要存它的信息,还需要存储它后继元素的存储地址。
我们把存储元素信息的域称为数据域,⽽把存储后继元素地址的域称为指针域。
由这两部分共同组成的数据元素ai,则可以称之为节点(Node)。
源代码--数据结构与算法(Python版)chap8 图
最短路径
最短路径是指两个顶点(源点到终 点)之间经过的边上权值之和最少 的路径。
下面介绍两种计算最短路径算法:
迪杰斯特拉(Djikstra)算法
佛洛伊德(Floyd)算法。
23
最短路径
1. 迪杰斯特拉(Djikstra)算法 迪杰斯特拉算法并非一下子求出起始点到结束点的 最短路径,而是一步步求出它们之间顶点的最短路 径,即基于已经求出的最短路径,逐步求得更远顶 点的最短路径,最终达到目的。通过Dijkstra计算图 G中的最短路径时,需要引进两个集合S和U。其中 ,集合S用于存放已求出最短路径的顶点(以及相 应的最短路径长度),集合U用于存放还未求出最 短路径的顶点(以及该顶点到起点的距离)。
u = q.popleft() print(u," ",end="") for w in G[u]:
if w not in visited: q.append(w) visited.add(w)
print('广度深度优先bfs') bfs(G, 0)
16
最小生成树
构造连通图的最小代价生成树称为 最小生成树。 最小生成树实现算法:
11
递归深度优先
from collections import deque def dfs(G, v, visited=set()):
print(v," ",end="") visited.add(v) # 用来存放已经访问过的顶点 # G[v] 是这个顶点的相邻的顶点 for u in G[v]:
24
最短路径
迪杰斯特拉算法具体步骤包括:
步骤1:初始时,S只包含起点s;U包含除s外的其他顶点,且U中顶点 的距离为"起点s到该顶点的距离,若s和v不相邻,则距离为∞。 步骤2:从U中选出距离最短的顶点k,并将顶点k加入到S中;同时,从 U中移除顶点k。 步骤3:更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离 ,是由于上一步中确定了k是求出最短路径的顶点,从而借助中间定点后 的距离可能小于两顶点的直接距离,即 (s,k)+(k,v)可能小于(s,v)。 步骤4: 重复步骤步骤2和步骤3,直到遍历完所有顶点。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
算法与数据结构算法与流程图
10 图与网的定义和术语
算法设计要求
正确性
程序对于典型、苛刻而带有刁难性的几组输入数据能够得 出满足规格说明要求的结果
可读性 健壮性
当输入数据非法时,能够适当地做出反应或者进行处理, 而不会产生莫名其妙的结果
效率与低存储量需求
顺序结构3-1
顺序结构的流程图:
20 图与网的定义和术语
顺序结构3-2
21
顺序结构3-3
22 图与网的定义和术语
选择结构的流程图:
选择结构2-1
23 图与网的定义和术语
选择结构2-2
24
循环结构2-1
循环结构的流程图:
25 图与网的定义和术语
循环结构2-2
从键盘输入9 个数,找出最大值
7 图与网的定义和术语
数据结构的基本概念和术语6-6
数据对象(Data Object)---是具有相同性质的数据元素的集合, 是数据的一个子集。例如,整数数据对象是集合N={0,±1, ±2,…},字母字符数据对象是集合C={'A', 'B', …, 'Z'}。本节的 学籍表也可看成一个数据对象。
14 图与网的定义和术语
算法描述(流程图)
15
算法描述(N-S流程图)
16 图与网的定义和术语
算法的C语句实现
17 图与网的定义和术语
符号
18
流程图符号
说明
程序的开始或结束 计算步骤
输入/输出指令 判断和分支 连接符 流程线
顺序结构 选择结构 循环结构
C程序的基本结构
19 图与网的定义和术语
数据结构--线性表的基本运算及多项式的算术运算
数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。
要求:能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
二、实验环境(实验设备)X64架构计算机一台,Windows 7操作系统,IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一:实现顺序表和单链表的实现本程序包含了四个文件,分别是LinearListMain.cpp,linearlist.h,seqlist.h,singlelist.h。
分别是主程序,线性表抽象类,顺序储存线性表的实现,链表储存顺序表的实现。
文件之间的关系图:本程序一共包含了三个类:分别是LinearList(线性表抽象类),SeqList(顺序储存的线性表),SingleList(链表储存的线性表)。
类与类之间的关系图如下:其实,抽象类LinearList规定了公共接口。
分别派生了SeqList类和SingleList。
SingleList类与SingleList类分别实现了LinearList类中的所有接口。
程序代码以及分析:Linearlist类:#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中,成功返回true,否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素,找到返回true,否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n,和8种运算,具体说明见注释。
py graph用法
py graph用法Python中的graph(图)是一种强大的数据结构,用于存储和表示实体(节点)之间的关系(边)。
图可以用于解决许多实际问题,如社交网络分析、路径规划和推荐系统。
本文将一步一步回答关于Python图使用方法的问题,帮助读者了解如何操作和利用图数据结构。
一、为什么选择Python中的graph?Python是一种灵活而强大的编程语言,拥有许多用于数据分析和可视化的库。
其中,networkx是一个用于复杂网络(包括图)分析的流行库。
它提供了创建、操作和可视化图的一组工具。
通过使用networkx,我们可以方便地构建和分析图结构。
二、如何创建一个空的graph?在Python中,我们可以使用networkx库的Graph类来创建一个空的图。
下面是创建一个空的无向图的示例代码:import networkx as nxG = nx.Graph()三、如何向图中添加节点?在Python中,你可以通过调用add_node()方法向图中添加节点。
下面是向图中添加节点的示例代码:G.add_node(1)G.add_node("A")G.add_node("John")以上代码分别向图中添加整数节点1,字符串节点"A"和"John"。
四、如何向图中添加边?添加边是连接节点的行为。
在Python中,可以通过调用add_edge()方法向图中添加边。
下面是向图中添加边的示例代码:G.add_edge(1, 2)G.add_edge("A", "B")G.add_edge("John", "Smith")以上代码分别在节点1和2之间,节点"A"和"B"之间,节点"John"和"Smith"之间添加了边。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构图基本算代码————————————————————————————————作者:————————————————————————————————日期:#include"iostream"#include"LGraph.h"#include"seqqueue.h"#include"MGraph.h"#define INFTY 1000template<class T>struct ENode{ENode(){nextArc=NULL;}ENode(int vertex,T weight,ENode *next){adjVex=vertex;w=weight;nextArc=next;}int adjVex;T w;ENode* nextArc;};template<class T>class ExtLGraph:public LGraph<T>{public:ExtLGraph(int mSize):LGraph<T>(mSize){} void DFS();void BFS();void TopoSort(int *order);private:void CalInDegree(int *InDegree);void DFS(int v,bool *visited);void BFS(int v,bool *visited);};template<class T>void ExtLGraph<T>::DFS(){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=0;i<n;i++)if(!visited[i]) DFS(i,visited);delete []visited;}template<class T>void ExtLGraph<T>::DFS(int v,bool *visited){visited[v]=true;cout<<" "<<v;for(ENode<T> *t=a[v];t;t=t->nextArc)if(!visited[t->adjVex])DFS(t->adjVex,visited);}template<class T>void ExtLGraph<T>::BFS(){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=0;i<n;i++)if(!visited[i]) BFS(i,visited);delete []visited;}template<class T>void ExtLGraph<T>::BFS(int v,bool *visited){SeqQueue<int>q(Vertices());visited[v]=true;cout<<" "<<v;q.EnQueue(v);while(!q.IsEmpty()){q.Front(v);q.DeQueue();for(ENode<T> *t=a[v];t;t=t->nextArc)if(!visited[t->adjVex]){visited[t->adjVex]=true;cout<<" "<<w->adjVex;}q.EnQueue(t->adjVex);}}template<class T>void ExtLGraph<T>::CalInDegree(int *InDegree) //计算所有顶点的入度for(int i=0;i<n;i++)InDegree[i]=0;for(i=0;i<n;i++)for(ENode<T>* p=a[i];p;p=p->nextArc)InDegree[p->adjVex]++;}template<class T>void ExtLGraph<T>::TopoSort(int *order){int *InDegree=new int[n];int i,j,k,top=-1;CalInDegree(InDegree);for(i=0;i<n;i++)if(!InDegree[i]){InDegree[i]=top;top=i;}for(i=0;i<n;i++){if(top==-1){cout<<"Has cycle!"<<endl;return;}else{j=top;top=InDegree[top];order[i]=j;cout<<j<<' ';for(ENode<T>* p=a[j];p;p=p->nextArc){k=p->adjVex;InDegree[k]--;if(!InDegree[k]){InDegree[k]=top;top=k;}}}}}template<class T>class ExtMGraph:public MGraph<T>{public:ExtMGraph(int mSize,const T&noedg):MGraph<T>(mSize,noedg){} void DFS();void BFS();void DFS(int v);void BFS(int v);int Choose(int *d,bool *s);void Dijkstra(int v,T *d,int *path);void ShowDijkstra(int v,int flag);void DijkstraForHomework(int v);//用于作业,该段代码与实验无关void Floyd(T **d,int **path);void FloydForHomework(int v);//用于作业,该段代码与实验无关private:void DFS(int v,bool *visited);void BFS(int v,bool *visited);};template<class T>void ExtMGraph<T>::DFS(int v){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=v;i<n;i++){if(!visited[i]) DFS(i,visited);}for(i=0;i<v;i++){if(!visited[i]) DFS(i,visited);}delete [] visited;}template<class T>void ExtMGraph<T>::DFS(){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=0;i<n;i++)if(!visited[i]) DFS(i,visited);delete []visited;}template<class T>void ExtMGraph<T>::DFS(int v,bool *visited) {visited[v]=true;cout<<" "<<v;for(int t=0;t<n;t++)if(a[v][t]!=noEdge&&!visited[t])DFS(t,visited);}template<class T>void ExtMGraph<T>::BFS(int v){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=v;i<n;i++)if(!visited[i]) BFS(i,visited);for(i=0;i<v;i++)if(!visited[i]) BFS(i,visited);delete [] visited;}template<class T>void ExtMGraph<T>::BFS(){bool *visited=new bool[n];for(int i=0;i<n;i++)visited[i]=false;for(i=0;i<n;i++)if(!visited[i]) BFS(i,visited);delete []visited;}template<class T>void ExtMGraph<T>::BFS(int v,bool *visited) {SeqQueue<int>q(Vertices());visited[v]=true;cout<<" "<<v;q.EnQueue(v);while(!q.IsEmpty()){q.Front(v);q.DeQueue();for(int j=0;j<n;j++)if(a[v][j]!=noEdge&&visited[j]!=true){cout<<" "<<j;visited[j]=true;q.EnQueue(j);}}}template<class T>int ExtMGraph<T>::Choose(int *d,bool *s){int i,minpos;T min;min=INFTY;minpos=-1;for(i=0;i<n;i++)if(d[i]<min&&!s[i]){min=d[i];minpos=i;}return minpos;}template<class T>void ExtMGraph<T>::Dijkstra(int v,T *d,int *path) {int i,k,w;if(v<0||v>n-1){cout<<"out of bounds!"<<endl;return;}bool *s=new bool[n];for(i=0;i<n;i++){s[i]=false;d[i]=a[v][i];if(i!=v&&d[i]<INFTY)path[i]=v;else path[i]=-1;}s[v]=true;d[v]=0;for(i=0;i<n;i++){k=Choose(d,s);if(k==-1) break; //若找不出下一个可连通的定点说明源点也无法到达别的定点,算法结束s[k]=true;for(w=0;w<n;w++)if(!s[w]&&d[k]+a[k][w]<d[w]){d[w]=d[k]+a[k][w];path[w]=k;}// showDandPath(k,n,d,path);}delete [] s;}template<class T>void showDandPath(int newS,int n,T *d,int *path)//用于作业,该段代码与实验无关{cout<<"--------S: "<<newS<<"-----------"<<endl;for(int i=0;i<n;i++)cout<<"d["<<i<<"]: "<<d[i]<<" | ";cout<<endl;for(i=0;i<n;i++)cout<<"path["<<i<<"]: "<<path[i]<<" | ";cout<<endl<<"---------------------------------"<<endl;}template<class T>void ExtMGraph<T>::DijkstraForHomework(int v)//用于作业,该段代码与实验无关{T *d=new T[n];int *path=new int[n];int i,k,w;if(v<0||v>n-1){cout<<"out of bounds!"<<endl;return;}bool *s=new bool[n];for(i=0;i<n;i++){s[i]=false;d[i]=a[v][i];if(i!=v&&d[i]<INFTY)path[i]=v;else path[i]=-1;}s[v]=true;d[v]=0;showDandPath(0,n,d,path);for(i=0;i<n;i++){k=Choose(d,s);if(k==-1) break; //若找不出下一个可连通的定点说明源点也无法到达别的定点,算法结束s[k]=true;for(w=0;w<n;w++)if(!s[w]&&d[k]+a[k][w]<d[w]){d[w]=d[k]+a[k][w];path[w]=k;}showDandPath(k,n,d,path);}delete []d;delete []path;}template<class T>void ExtMGraph<T>::ShowDijkstra(int v,int flag){T * dd=new T [n];int * ppath=new int [n];int temp;Dijkstra(v,dd,ppath);for(int ii=0;ii<n;ii++){cout<<ii<<": ";if(ii==v)cout<<"Source Point"<<endl;else{if(ppath[ii]==-1)cout<<"No path exist"<<endl;else{cout<<ii<<"<- ";temp=ppath[ii];while(ppath[temp]!=-1){cout<<temp<<"<- ";temp=ppath[temp];}if(flag==0)cout<<temp<<endl<<"----------total weight: "<<dd[ii]<<endl;else{if(flag==1)cout<<temp<<endl<<"----------change flight "<<dd[ii]-1<<" times"<<endl;elseif(flag==2)cout<<temp<<endl<<"----------change bus "<<dd[ii]-1<<" times"<<endl;}}}}delete []dd;delete []ppath;}template<class T>void ExtMGraph<T>::Floyd(T **d,int **path){int i,j,k;for(i=0;i<n;i++)for(j=0;j<n;j++){d[i][j]=a[i][j];if(i!=j&&a[i][j]<INFTY)path[i][j]=i;else path[i][j]=-1;}for(k=0;k<n;k++)for(i=0;i<n;i++)for(j=0;j<n;j++){d[i][j]=d[i][k]+d[k][j];path[i][j]=path[k][j];}}template<class T>void ExtMGraph<T>::FloydForHomework(int v)//用于作业,该段代码与实验无关{//初始化T **d=new T*[n];int **path=new int*[n];for(int i=0;i<n;i++){d[i]=new T[n];path[i]=new int[n];}//以下是Floyd算法,但是在“开始插入处”与“结束插入处”之间加入显示代码以写出二维树组d和path在执行算法的过程中各步的状态int k;for(i=0;i<n;i++)for(int t=0;t<n;t++){d[i][t]=a[i][t];if(i!=t&&a[i][t]<INFTY)path[i][t]=i;else path[i][t]=-1;}for(k=0;k<n;k++){//zzqfor(i=0;i<n;i++)for(int t=0;t<n;t++){d[i][t]=d[i][k]+d[k][t];path[i][t]=path[k][t];}//开始插入处cout<<"--------S: "<<k<<"-----------"<<endl;cout<<"d"<<k<<":"<<endl;for(i=0;i<n;i++){for(int j=0;j<n;j++){cout<<d[i][j]<<" ";}cout<<endl;}cout<<"------------------------------"<<endl;cout<<"path"<<k<<":"<<endl;for(i=0;i<n;i++){for(int j=0;j<n;j++){cout<<path[i][j]<<" ";}cout<<endl;}cout<<"------------------------------"<<endl;//结束插入处}//释放资源for(i=0;i<n;i++){delete []d[i];delete []path[i];}delete []d;delete []path;}void main(){int weight=3;int noEdge=1000;// Test of MGraph/* MGraph<int> mGraph(7,noEdge);int matrix[7][7]={0,1,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0};for(int i=0;i<7;i++){for(int j=0;j<7;j++)cout<<matrix[i][j]<<' ';cout<<endl;}mGraph.BuildforTest(*matrix,7,7);mGraph.OutputforTest(cout);mGraph.DeleteforTest();mGraph.OutputforTest(cout);showResultCode(mGraph.Insert(3,1,weight));showResultCode(mGraph.Insert(6,2,weight));mGraph.OutputforTest(cout);showResultCode(mGraph.Remove(3,1));*/// Test of LGraph and ExtLGraph/* LGraph<int> lGraph(7);int matrix[7][7]={0,1,0,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0};for(int i=0;i<7;i++){for(int j=0;j<7;j++)cout<<matrix[i][j]<<' ';cout<<endl;}lGraph.BuildforTest(*matrix,7,7);lGraph.OutputforTest(cout);lGraph.DeleteforTest();lGraph.OutputforTest(cout);showResultCode(lGraph.Insert(3,1,weight));showResultCode(lGraph.Insert(6,2,weight));lGraph.OutputforTest(cout);*//*// Test of DFS in ExtMGraphExtMGraph<int> extMGraph(8,noEdge);showResultCode(extMGraph.Insert(0,1,weight));showResultCode(extMGraph.Insert(0,6,weight));showResultCode(extMGraph.Insert(1,3,weight));showResultCode(extMGraph.Insert(1,4,weight));showResultCode(extMGraph.Insert(2,5,weight));showResultCode(extMGraph.Insert(6,2,weight));showResultCode(extMGraph.Insert(7,0,weight));cout<<"DFS"<<endl;extMGraph.DFS();cout<<endl;extMGraph.DFS(7);cout<<endl;extMGraph.DFS(6);cout<<endl;extMGraph.DFS(5);extMGraph.DFS(4);cout<<endl;extMGraph.DFS(3);cout<<endl;extMGraph.DFS(2);cout<<endl;extMGraph.DFS(1);cout<<endl;cout<<"BFS"<<endl;extMGraph.BFS();cout<<endl;extMGraph.BFS(7);cout<<endl;extMGraph.BFS(6);cout<<endl;extMGraph.BFS(5);cout<<endl;extMGraph.BFS(4);cout<<endl;extMGraph.BFS(3);cout<<endl;extMGraph.BFS(2);cout<<endl;extMGraph.BFS(1);cout<<endl;// Test of BFS in ExtMGraphExtMGraph<int> extMGraph2(8,noEdge); showResultCode(extMGraph2.Insert(0,2,weight)); showResultCode(extMGraph2.Insert(1,3,weight)); showResultCode(extMGraph2.Insert(2,4,weight)); showResultCode(extMGraph2.Insert(3,5,weight)); showResultCode(extMGraph2.Insert(5,6,weight)); showResultCode(extMGraph2.Insert(6,7,weight)); showResultCode(extMGraph2.Insert(7,0,weight)); cout<<"BFS"<<endl;extMGraph2.BFS();cout<<endl;extMGraph2.BFS(7);cout<<endl;extMGraph2.BFS(6);cout<<endl;extMGraph2.BFS(5);extMGraph2.BFS(4);cout<<endl;extMGraph2.BFS(3);cout<<endl;extMGraph2.BFS(2);cout<<endl;extMGraph2.BFS(1);cout<<endl;cout<<"DFS"<<endl;extMGraph2.DFS();cout<<endl;extMGraph2.DFS(7);cout<<endl;extMGraph2.DFS(6);cout<<endl;extMGraph2.DFS(5);cout<<endl;extMGraph2.DFS(4);cout<<endl;extMGraph2.DFS(3);cout<<endl;extMGraph2.DFS(2);cout<<endl;extMGraph2.DFS(1);cout<<endl;}。