数据结构 复数ADT试验

复数ADT及其实现

实验报告

实验项目名称复数ADT及其实现

实验室152 室

所属课程名称数据结构

实验日期2011年3月29日

班级计算机四班

学号409109070428

姓名邓洋

成绩

实验一复数ADT及其实现

一、实验目的

1. 了解抽象数据类型（ADT）的基本概念，及描述方法。

2. 通过对复数抽象数据类型ADT的实现，熟悉C语言语法及程序设计。为以

后章节的学习打下基础。

二、实验环境

1.环境：宿舍，实验室152。

2.硬件：PC微型计算机，2048M内存，500G硬盘。

3.系统：Windows GhostXP SP3

4.软件平台：MiCrosoft VisuCl C++ 6.0简体中文版

三、实验内容

1.熟悉C 语言的上机环境，掌握C 语言的基本结构。

2.写出复数的ADT，熟悉ADT的结构。

3.以C语言代码定义数据类型实现复数的相加，相减等运算操作。

4.通过抽象数据类型复数的C语言实现,熟悉对数据类型的封闭和相应操作的定义与实

现。

四、实验程序

1.复数抽象数据类型ADT的描述。

ADT Complex0428{

数据对象：D={ C，b |C,b∈FloCtSet }

数据关系：R={ |C,b∈D}

基本操作：

InitComplex0428(&a);

操作结果：创建一个复数

Coutput0428(a);

操作结果：输出一个复数

CCdd0428(a,b);

操作结果：求两个复数相加之和

Csub0428(a,b);

操作结果：求两个复数相减之差

Cmul0428(a，b);

操作结果：求两个复数相乘之积

Cdiv0428(a，b);

操作结果：求两个复数相除之商

} ADT Complex0428;

2.ADT的C语言形式说明

typedef struct Complex0428

{

float real; //复数的实部

float imag; //复数的虚部

}Complex0428;

Status InitComplex0428(Complex0428 &a, float real, float imag);

//初始化复数a。

void Coutput0428(Complex0428 a);

//输出复数a的值。

Complex0428 Cadd0428(Complex0428 a, Complex0428 b);

//返回复数a和b之和

Complex0428 Csub0428(Complex0428 a,Complex0428 b);

//返回复数a和b之差

Complex0428 Cmul0428(Complex0428 a,Complex0428 b);

//返回复数a和b之积

Complex0428 Cdiv0428(Complex0428 a,Complex0428 b);

//返回复数a和b之商

3.C语言相关操作

Status InitComplex0428 (Complex0428 &a,float real,float imag)

{//初始化复数a。

a.real= real;

a.imag= imag;

return OK;

}

void Coutput0428 (Complex0428 a)

{ //输出复数a的值。

printf("%f",a.real);

if(a.imag>0) printf("+ %f",a.imag);

if(a.imag<0) printf("%f",a.imag);

printf(“\n”);

}

Complex0428 Cadd0428(Complex0428 a, Complex0428 b)

{//返回复数a和b的之和a+b

c.real= a.real b.real;

c.imag= a.imag+ b.imag;

return c;

}

Complex0428 Csub0428(Complex0428 a,Complex0428 b)

{//返回复数a和b的之差a-b

c.real= a.real-b.real;

c.imag= a.imag-b.imag;

return c;

}

Complex0428 Cmul0428 (Complex0428 a,Complex0428 b)

{//返回复数a和b的之积a*b

c.real= a.real *b.real- a.imag*b.imag;

c.imag= a.imag-b.real+ a.real*b.imag;

return c;

}

Complex0428 Cdiv0428(Complex0428 a,Complex0428 b)

{//返回复数a和b的之商a/b

c.real=(a.real*b.real+a.imag*b.imag)/(b.real*b.real+b.imag*b.imag); c.imag=(a.imag*b.real-a.real*b.imag)/b.real*b.real+b.imag*b.imag);

return c;

}

4.上机调试操作

(1)新建Win32 Console Application工程，工程名为Lab01，选择一个“hello

world！”程序。

(2)准备实验所需的头文件。

头文件define.h内容如下：

#if !defined(AFX_COMPLEX_H__F6B5DDD6_CF6E_2F690582F908__INCLUDED_)

#define AFX_COMPLEX_H__F6B5DDD6_CF6E_2F690582F908__INCLUDED_ typedef int Status;

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#endif

(3）.类CComplex0428声明和定义：

一．声明：

// Complex0428.h: interface for the CComplex0428 class.

//

///////////////////////////////////////////////////////////////////// /

#if !defined(AFX_COMPLEX0428_H__1091A608_CE2A_42D1_8437_2AC3780B2316_ _INCLUDED_)

#define

AFX_COMPLEX0428_H__1091A608_CE2A_42D1_8437_2AC3780B2316__INCLUDED_

#include "define.h" // Added by ClassView

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

typedef struct Complex0428

{

float real; //复数的实部

float imag; //复数的虚部

}Complex0428;

class CComplex0428

{

public:

Status InitComplex0428 (Complex0428 &a,float real,float imag);

Complex0428 Cdiv0428(Complex0428 a,Complex0428 b);

Complex0428 Cmul0428(Complex0428 a,Complex0428 b);

Complex0428 Csub0428(Complex0428 a,Complex0428 b);

Complex0428 Cadd0428(Complex0428 a,Complex0428 b);

void Coutput0428(Complex0428 a);

CComplex0428();

virtual ~CComplex0428();

};

#endif

// !defined(AFX_COMPLEX0428_H__1091A608_CE2A_42D1_8437_2AC3780B2316__ INCLUDED_)

二．定义

// Complex0428.cpp: implementation of the CComplex0428 class.

//

///////////////////////////////////////////////////////////////////// /

#include "stdafx.h"

#include "Complex0428.h"

///////////////////////////////////////////////////////////////////// /

// Construction/Destruction

///////////////////////////////////////////////////////////////////// /

CComplex0428::CComplex0428()

{

}

CComplex0428::~CComplex0428()

{

}

void CComplex0428::Coutput0428(Complex0428 a)

{

//输出复数a的值。

printf("%0.4f",a.real);

if(a.imag>0) printf("+ %0.4fi",a.imag);

if(a.imag<0) printf("%0.4fi",a.imag);

printf("\n");

}

Complex0428 CComplex0428::Cadd0428(Complex0428 a, Complex0428 b)

{

//返回复数a和b的之和a+b

Complex0428 c;

c.real= a.real+b.real;

c.imag= a.imag+ b.imag;

return c;

}

Complex0428 CComplex0428::Csub0428(Complex0428 a, Complex0428 b)

{

//返回复数a和b的之差a-b

Complex0428 c;

c.real= a.real-b.real;

c.imag= a.imag-b.imag;

return c;

}

Complex0428 CComplex0428::Cmul0428(Complex0428 a, Complex0428 b)

{

//返回复数a和b的之积a*b

Complex0428 c;

c.real= a.real *b.real- a.imag*b.imag;

c.imag= a.imag-b.real+ a.real*b.imag;

return c;

}

Complex0428 CComplex0428::Cdiv0428(Complex0428 a, Complex0428 b)

{

//返回复数a和b的之商a/b

Complex0428 c;

c.real=(a.real*b.real+a.imag*b.imag)/(b.real*b.real+b.imag*b.imag); c.imag=((a.imag*b.real)-(a.real*b.imag))/(b.real*b.real+b.imag*b.imag );

return c;

}

Status CComplex0428::InitComplex0428(Complex0428 &a, float real,float imag)

{

//初始化复数a。

a.real= real;

a.imag= imag;

return OK;

}

（4）.main函数的准备一．流程图

lab01.01主程序的流程图

二．主函数函数清单：

// Lab01.cpp : Defines the entry point for the console application. //

#include "stdafx.h"

#include "stdlib.h"

#include "conio.h"

#include "Complex0428.h"

int main(int argc, char* argv[])

{

Complex0428 a,b,cadd,csub,cmul,cdiv;//定义变量

CComplex0428 c;//定义类

int i;

while(i!=0)

{

float real,imag,real2,imag2;

printf("请输入要参与运算的两个复数的实部和虚部（用空格或者回车隔开）：\n");

scanf("%f",&real);

scanf("%f",&imag);

scanf("%f",&real2); //输入要计算的复数

scanf("%f",&imag2);

c.InitComplex0428(a,real,imag);

c.InitComplex0428(b,real2,imag2);

cadd=c.Cadd0428(a,b);

csub=c.Csub0428(a,b);//左边所有为计算

cmul=c.Cmul0428(a,b);

cdiv=c.Cdiv0428(a,b);

printf("\n 第一个复数的大小为 : ");c.Coutput0428(a);

printf("\n 第二个复数的大小为 : ");c.Coutput0428(b);

printf("\n 两个复数相加的和为 : ");c.Coutput0428(cadd);

printf("\n 两个复数相减的差为 : ");c.Coutput0428(csub);//左边所有为输出

printf("\n 两个复数相乘的积为 : ");c.Coutput0428(cmul);

printf("\n 两个复数相除的商为 : ");c.Coutput0428(cdiv);

getch();//缓冲

printf("如果想结束计算，将按 0 键，如要继续将按任意键。\n");//循环计算

scanf("%d",&i);

system("cls");//清屏

}

return 0;

}

（5）.调试结果

1.以下为程序的调试结果图，因为使用了循环和清屏函数所以完整的图就没法在这里放出来。

具体完整的程序，请参照Lab01文件夹里的程序，程序调试的debug已经删去。

图lab01.02 程序的调试界面图

2.程序调试过程中的实例

1）请输入要参与运算的两个复数的实部和虚部（用空格或者回车隔开）：

2 3 3 4

第一个复数的大小为: 2.0000+ 3.0000i

第二个复数的大小为: 3.0000+ 4.0000i

两个复数相加的和为: 5.0000+ 7.0000i

两个复数相减的差为: -1.0000-1.0000i

两个复数相乘的积为: -6.0000+ 8.0000i

两个复数相除的商为: 0.7200+ 0.0400i

如果想结束计算，将按0 键，如要继续将按任意键。

2）请输入要参与运算的两个复数的实部和虚部（用空格或者回车隔开）：23 23 23 23

第一个复数的大小为: 23.0000+ 23.0000i

第二个复数的大小为: 23.0000+ 23.0000i

两个复数相加的和为: 46.0000+ 46.0000i

两个复数相减的差为: 0.0000

两个复数相乘的积为: 0.0000+ 529.0000i

两个复数相除的商为: 1.0000

如果想结束计算，将按0 键，如要继续将按任意键。

3）请输入要参与运算的两个复数的实部和虚部（用空格或者回车隔开）：325 12 564 23

第一个复数的大小为: 325.0000+ 12.0000i

第二个复数的大小为: 564.0000+ 23.0000i

两个复数相加的和为: 889.0000+ 35.0000i

两个复数相减的差为: -239.0000-11.0000i

两个复数相乘的积为: 183024.0000+ 6923.0000i

两个复数相除的商为: 0.5762-0.0022i

如果想结束计算，将按0 键，如要继续将按任意键。

4）请输入要参与运算的两个复数的实部和虚部（用空格或者回车隔开）：-231 56 123 -5646

第一个复数的大小为: -231.0000+ 56.0000i

第二个复数的大小为: 123.0000-5646.0000i

两个复数相加的和为: -108.0000-5590.0000i

两个复数相减的差为: -354.0000+ 5702.0000i

两个复数相乘的积为: 287763.0000+ 1304159.0000i

两个复数相除的商为: -0.0108-0.0407i

如果想结束计算，将按0 键，如要继续将按任意键。

3.根据以上程序调试的实例可以得知，本程序已经没有错误，其他微小瑕疵既看不出来，也不影响程序。因而此次实验已经达到我的目的。

五．实验小结

1.本次实验的使我回忆起了C语言的学习，使我能够再次运用C语言与C++两种语言进行编程学习。

2.初步明白了数据结构的学习方向，明白数据结构的学习意图。

3.学会了此类实验报告格式的书写，从ADT到C语言形式描述，再到程序的步骤。

4.此次实验再次加固了我的学习热情，让我为了做好实验而翻阅书籍。

六、选作实验

1. 实现抽象数据类型的除法。

实验报告中红色的部分，就是复数的除法的相关操作！

数据结构实验报告——顺序表链表的实现

课程名称：数据结构任课教师： 实验题目：线性表的基本操作 实验环境： Visual C++ 6.0 实验目的： 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的的顺表序和链表，使其具有如下功能： (1)根据指定学生个数，逐个输入学生信息; (2)逐个显示学生表中所有学生的相关信息；

(3)根据姓名进行查找，返回此学生的学号和成绩；

(4)根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5)给定一个学生信息，插入到表中指定的位置； int createStLink(struct Node *head,struct Node *stu) { struct Node *p6,*p7,*p8; p7=head; p6=stu; if(head==NULL) { head=p6;p6->next=NULL; } else { //如果链表为空则在头结点创建信息while(p6->num > p7->num && p7->next!=NULL)

{ p8=p7; p7=p7->next; } if(p6->num<=p7->num) { if(head==p7) head=p6; else p8->next=p6; p6->next=p7; } else { p7->next=p6;p6->next=NULL; } } N++; return 1; } int main() { struct Node *H,*stud; char M; int num1; H=initlist(); (6)删除指定位置的学生记录;

数据结构作业系统第七章答案

7.22③试基于图的深度优先搜索策略写一算法，判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径(i≠j)。注意：算法中涉及的图的基本操作必须在此存储结构上实现。 实现下列函数： Status DfsReachable(ALGraph g, int i, int j); /* Judge if it exists a path from vertex 'i' to */ /* vertex 'j' in digraph 'g'. */ /* Array 'visited[]' has been initialed to 'false'.*/ 图的邻接表以及相关类型和辅助变量定义如下：Status visited[MAX_VERTEX_NUM]; typedef char VertexType; typedef struct ArcNode { int adjvex; struct ArcNode *nextarc; } ArcNode; typedef struct VNode { V ertexType data; ArcNode *firstarc; } VNode, AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices; int vexnum, arcnum; } ALGraph; Status DfsReachable(ALGraph g, int i, int j) /* Judge if it exists a path from vertex 'i' to */ /* vertex 'j' in digraph 'g'. */ /* Array 'visited[]' has been initialed to 'false'.*/ { int k; ArcNode *p; visited[i]=1; for(p=g.vertices[i].firstarc;p;p=p->nextarc) { if(p) { k=p->adjvex; if(k==j)return 1; if(visited[k]!=1)

数据结构 图的基本操作实现

实验五图的遍历及其应用实现 一、实验目的 1．熟悉图常用的存储结构。 2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。 3．会用图的遍历解决简单的实际问题。 二、实验内容 [题目一] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。该程序包括图类型以及每一种操作的具体的函数定义和主函数。 提示： 输入示例 上图的顶点和边的信息输入数据为： 5 7 DG A B C D E AB AE BC CD DA DB EC [题目二]：在图G中求一条从顶点 i 到顶点 s 的简单路径 [题目三]：寻求最佳旅游线路（ACM训练题） 在一个旅游交通网中，判断图中从某个城市A到B是否存在旅游费用在s1-s2元的旅游线路，为节省费用，不重游故地。若存在这样的旅游线路则并指出该旅游线路及其费用。 输入： 第一行：n //n-旅游城市个数 第2行：A B s1 s2 //s1,s2-金额数 第3行---第e+2行 ( 1≤e≤n(n-1)/2 ) 表示城市x,y之间的旅行费用，输入0 0 0 表示结束。

输出： 第一行表示 A到B的旅游线路景点序列 第二行表示沿此线路，从A到B的旅游费用 设计要求： 1、上机前，认真学习教材，熟练掌握图的构造和遍历算法,图的存储结 构也可使用邻接矩阵等其他结构. 2、上机前，认真独立地写出本次程序清单，流程图。图的构造和遍历算法 分别参阅讲义和参考教材事例 图的存储结构定义参考教材 相关函数声明： 1、/* 输入图的顶点和边的信息,建立图*/ void CreateGraph(MGraph &G) 2、/* 深度优先搜索遍历图*/ void DFSTraverse(Graph G, int v) 3、/*广度优先搜索遍历图 */ void BFSTraverse(Graph G, int v)4、 4、/* 其他相关函数 */…… 三、实验步骤 ㈠、数据结构与核心算法的设计描述 ㈡、函数调用及主函数设计 （可用函数的调用关系图说明） ㈢程序调试及运行结果分析 ㈣实验总结 四、主要算法流程图及程序清单 1、主要算法流程图： 2、程序清单 （程序过长，可附主要部分）

数据结构- 顺序表的基本操作的实现-课程设计-实验报告

顺序表的基本操作的实现 一、实验目的 1、掌握使用VC++上机调试顺序表的基本方法； 2、掌握顺序表的基本操作：建立、插入、删除等运算。 二、实验仪器 安装VC++软件的计算机。 三、实验原理 利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容 程序中演示了顺序表的创建、插入和删除。 程序如下： #include #include /*顺序表的定义：*/ #define ListSize 100 typedef struct { int data[ListSize]; /*向量data用于存放表结点*/ i nt length; /*当前的表长度*/ }SeqList; void main() { void CreateList(SeqList *L,int n); v oid PrintList(SeqList *L,int n); i nt LocateList(SeqList *L,int x); v oid InsertList(SeqList *L,int x,int i); v oid DeleteList(SeqList *L,int i); SeqList L;

i nt i,x; i nt n=10; L.length=0; c lrscr(); C reateList(&L,n); /*建立顺序表*/ P rintList(&L,n); /*打印建立后的顺序表*/ p rintf("INPUT THE RESEARCH ELEMENT"); s canf("%d",&x); i=LocateList(&L,x); p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n"); s canf("%d",&i); p rintf("input the value of insert\n"); s canf("%d",&x); I nsertList(&L,x,i); /*顺序表插入*/ P rintList(&L,n); /*打印插入后的顺序表*/ p rintf("input the position of delete\n"); s canf("%d",&i); D eleteList(&L,i); /*顺序表删除*/ P rintList(&L,n); /*打印删除后的顺序表*/ g etchar(); } /*顺序表的建立：*/ void CreateList(SeqList *L,int n) {int i; printf("please input n numbers\n"); for(i=1;i<=n;i++) scanf("%d",&L->data[i]); L->length=n;

c#数据库连接、操作、封装dll

c#数据库连接去sql server 为了简化数据库连接和操作，编写一个数据库dll文件也是比较有用的。只需要设置参数就可以完成数据库操作 属性 OUTPUTSTR 存储过程输出 CONSTR 数据库连接字符串 SQL_SLT 存储过程名或sql语句列表名 代码错误信息返回或连接关闭状态 public int sql_select(int cmdtype, int sqlst,int n) 数据库语句执行方法， cmdtype设置数据源执行的SQL语句或存储过程，即commandtype属性（0为text枚举，1为storedprocedure枚举，其他值为tabledirect枚举）； sqlst设置执行SQL语句的方式，0为executenonquery方法执行，1为executereader 方法执行，其他为executescalar方法执行。设置存储过程参数个数。方法返回受 影响的行数 public Boolean Connopen() 打开数据库连接方法，返回bool值，true为打开，false 为未打开，并将未打开错误返回到EXSTR属性里 public void conn_close() 连接关闭方法，将关闭状态返回到EXSTR属性 public void sqlsp(string p1,string p2,string p3,int p4,int p5) 获取SqlParameter 对象参数，p1获取SqlParameter.ParameterName属性值，p2获取SqlParameter.sqldbtype属性值， p3获取SqlParameter.value属性值，p4获取SqlParameter.size属性值， p5设置SqlParameter.Directions属性值，0为ParameterDirection.Input、 1为ParameterDirection.InputOutput、2为ParameterDirection.Output、 大于3为ParameterDirection.ReturnValue public DataSet ds 返回查询结果集 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Data.SqlClient; using System.Data; using System.Collections; namespace connet { public class jdbccoonn { private string constr, exstr, sql_slt,outputstr; private static int q; public static int Q { get {

数据结构作业电子版

1数据结构课程研究的主要内容包括（）（）（） 2一个完整的算法应该具有_____ _____ ______ ______ ______五个特性 3数据的逻辑结构可分为_____ ______两大类 4数据的逻辑结构是指而存储结构是指 5逻辑上相邻的数据元素在物理位置上也相邻是存储结构的特点之一 6为了实现随机访问线性结构应该采用存储结构 7链式存储结构的主要特点是 8算法分析主要从和这两个方面对算法进行分析 （1）数据 （2）数据元素 （3）数据类型 （4）数据结构 （5）逻辑结构 （6）存储结构 （7）线性结构 （8）非线性结构 第二章作业 一、判断题(在你认为正确的题后的括号中打√，否则打X)。 1．线性表的逻辑顺序与存储顺序总是一致的。 2．顺序存储的线性表可以按序号随机存取。 3．顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。 4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。 5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。 6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。7．线性表的链式存储结构优于顺序存储结构。 8．在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。 9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。 二、单项选择题。 1．线性表是( ) 。 (A) 一个有限序列，可以为空； (B) 一个有限序列，不能为空； (C) 一个无限序列，可以为空； (D) 一个无序序列，不能为空。 2．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。插入一个元素时平均要移动表中的（）个元素。 (A) n/2 (B) n+1/2 (C) n -1/2 (D) n 3．线性表采用链式存储时，其地址( ) 。

数据结构顺序表的实现

实验3 顺序表 一、实验目的 1. 熟练掌握顺序表的类型定义和基本操作算法（以建立、插入、删除、遍历、排序和归并等操作为重点）的实现。 2. 通过实验加深对C语言的使用（特别是函数、数组、结构体和指针）。 3. 掌握模块化程序设计方法。 二、预备知识 1. 顺序表的类型定义 //线性表存储空间的初始分配量 #define LIST_Init_Size 100 //线性表存储空间的分配增量 #define LISTINCREMENT 10 typedef struct{ ElemType *elem; //存储区域基地址 int length; //当前有效长度 int listsize；//当前分配的存储容量 } SqList, *PSqList; 2. 顺序表的基本操作 1）初始化线性表InitList(&L) 该运算的结果是构造一个空的线性表L，为线性表分配存储空间用于存放数据元素。 2）销毁线性表DestroyList(&L ) 该运算的结果是释放线性表L占用的内存空间。 3）判定是否为空表ListEmpty(L)

该运算返回一个值表示L是否为空表。若L为空表,则返回1,否则返回0。4）求线性表的长度ListLength(L) 该运算返回顺序表L的长度。实际上只需返回length成员的值即可。 5）PriorElem( L, cur_e, &pre_e ) 该运算返回给定数据元素的前驱数据元素的值 6）NextElem( L, cur_e, &next_e ) 该运算返回给定数据元素的后继数据元素的值 7）输出线性表DispList(L) 该运算当线性表L不为空时,顺序输出L中各数据元素的值。 8）求某个数据元素值GetElem(L,i,&e) 该运算返回L中第i(1≤i≤ListLength(L))个元素的值,存放在e中。 8）按元素值查找LocateElem(L,e) 该运算顺序查找第1个值域与e相等的数据元素的序号。若这样的元素不存在,则返回值为0。 9）插入数据元素ListInsert(&L,i,e) 该运算在顺序表L的第i个位置(1≤i≤ListLength(L)+1)上插入新的元素e。10）删除数据元素ListDelete(&L,i,&e) 该运算删除顺序表L的第i(1≤i≤ListLength(L))个元素。 11）清空线性表ClearList( &L ) 删除线性表L中的所有数据元素，但不释放已分配给线性表的存储空间。2. 两个有序表的归并算法 void MergeList(SqList La, SqList Lb, PSqList PLc) { InitList(PLc); // 构造空的线性表Lc i = j = 1; k = 1; La_len = ListLength(La); Lb_len = ListLength(Lb);

数据结构实现顺序表的各种基本运算(20210215233821)

实现顺序表的各种基本运算 一、实验目的 了解顺序表的结构特点及有关概念，掌握顺序表的各种基本操作算法思想及其实现。 二、实验内容 编写一个程序，实现顺序表的各种基本运算： 1、初始化顺序表； 2 、顺序表的插入； 3、顺序表的输出； 4 、求顺序表的长度 5 、判断顺序表是否为空； 6 、输出顺序表的第i位置的个元素； 7 、在顺序表中查找一个给定元素在表中的位置； 8、顺序表的删除； 9 、释放顺序表 三、算法思想与算法描述简图

主函数main

四、实验步骤与算法实现 #in clude #in clude #defi ne MaxSize 50 typedef char ElemType; typedef struct {ElemType data[MaxSize]; in t le ngth; void In itList(SqList*&L)〃 初始化顺序表 L {L=(SqList*)malloc(sizeof(SqList)); L->le ngth=0; for(i=0;ile ngth;i++) prin tf("%c ",L->data[i]); } void DestroyList(SqList*&L)〃 {free(L); } int ListEmpty(SqList*L)〃 {retur n( L->le ngth==O); } int Listle ngth(SqList*L)〃 {return(L->le ngth); } void DispList(SqList*L)〃 {int i; 释放顺序表 L

c#下各种数据库操作的封装!

c#下各种数据库操作的封装！(支持ACCESS,SQLSERVER,DB2,ORACLE, MYSQL)（一）收藏 首先定义数据库操作的标准接口IDBAccess,定义接口的基本功能； 通过基本的接口设置，完成数据访问的统一抽象。 public interface IDBAccess { void Init(string strServer, string strDataBase, string strUser, string str Pwd); void Open(); void Close(); bool TestConn(); int RunNoQuery(string strCmd); DataTable RunQuery(string strCmd); DBType DBType { get;} int GetFiledMax(string strTable, string strField); DataTable Tables { get; } DataTable GetColumns(); DataTable GetColumns(string strTable); } c#下各种数据库操作的封装！(支持ACCESS,SQLSERVER,DB2,ORACLE, MYSQL)（二）收藏 使用静态工厂模式，通过传入枚举型参数，动态创建访问实例 实现模式上采用基本实现接口，派生类继承基类的虚函数，从而实现代码的耦合较低，有很好的扩展性。 public enum DBType {

Access, SQL, DB2, Oracle, MySQL } public static class DBAccessFactory { public static IDBAccess Create(DBType type) { IDBAccess IRet = null; switch (type) { case DBType.Access: IRet = new Access(type); break; case DBType.SQL: IRet = new SQL(type); break; default: break; } return IRet; } private abstract class DBAccess : IDBAccess {

数据结构--图的应用及其实现

实验六图的应用及其实现 （相关知识点：拓扑排序、关键路径、最小生成树和最短路径） 一、实验目的 1．进一步功固图常用的存储结构。 2．熟练掌握在图的邻接表实现图的基本操作。 3．理解掌握AOV网、AOE网在邻接表上的实现以及解决简单的应用问题。 二、实验内容 一>.基础题目：(本类题目属于验证性的，要求学生独立完成) [题目一]：从键盘上输入AOV网的顶点和有向边的信息,建立其邻接表存储结构,然后对该图拓扑排序,并输出拓扑序列. 试设计程序实现上述AOV网的类型定义和基本操作,完成上述功能。 测试数据：教材图7.28 [题目二]：从键盘上输入AOE网的顶点和有向边的信息,建立其邻接表存储结构,输出其关键路径和关键路径长度。试设计程序实现上述AOE网类型定义和基本操作,完成上述功能。 测试数据：教材图7.29 二>.简单应用题目：（ACM/ICPC训练题，本类题目属于设计性的，要求学生三人为一个团队，分工协作完成)） 【题目三】高速公路 描述 某国共有n个城市（n不超过200），有些城市之间直接有一条高速公路相连，高速公路都是双向的，总共有m条。每条高速公路都有自己的载重限制，即载重最大值。通过车辆的载重不能超过公路的载重限制。如今我们想了解的是，从某一起点城市出发，到达目标城市，车辆最多能带多重的货物。 输入 输入的第一行为两个整数n和m。以下有m行，每行三个整数描述一条公路，分别是首尾相连的城市以及载重限制。然后是一个整数k，即问题个数。接下来k行描述k个问题，每行两个整数表示起点城市和目标城市。问题数不超过一百。 输出

输出包括k行，每行对应一个问题，输出从起点到目标的最大载重量。如果两城市间无路径则输出-1。 样例输入 3 3 1 2 100 2 3 100 1 3 50 2 1 3 2 3 样例输出 100 100 【题目四】最短的旅程 描述 在Byteland有n个城市（编号从1到n），它们之间通过双向的道路相连。Byteland 的国王并不大方，所以，那里只有n -1条道路，但是，它们的连接方式使得从任意城市都可以走到其他的任何城市。 一天，starhder到了编号为k的城市。他计划从城市k开始，游遍城市m1，m2，m3……，mj（不一定要按这个顺序旅游）。每个城市mi都是不同的，并且，也与k不同。Starhder ——就像每一个旅行家一样，携带的钱总是有限的，所以，他要以最短的路程旅行完所有的城市（从城市k开始）。于是，他请你帮助计算一下，旅游完上述的城市最短需要多少路程。 输入

数据结构实验图的基本操作

浙江大学城市学院实验报告 课程名称数据结构 实验项目名称实验十三/十四图的基本操作 学生姓名专业班级学号 实验成绩指导老师（签名）日期2014/06/09 一.实验目的和要求 1、掌握图的主要存储结构。 2、学会对几种常见的图的存储结构进行基本操作。 二.实验内容 1、图的邻接矩阵定义及实现： 建立头文件test13_AdjM.h，在该文件中定义图的邻接矩阵存储结构，并编写图的初始化、建立图、输出图、输出图的每个顶点的度等基本操作实现函数。同时建立一个验证操作实现的主函数文件test13.cpp（以下图为例），编译并调试程序，直到正确运行。 2、图的邻接表的定义及实现： 建立头文件test13_AdjL.h，在该文件中定义图的邻接表存储结构，并编写图的初始化、建立图、输出图、输出图的每个顶点的度等基本操作实现函数。同时在主函数文件test13.cpp中调用这些函数进行验证（以下图为例）。

3、填写实验报告，实验报告文件取名为report13.doc。 4、上传实验报告文件report13.doc到BB。 注: 下载p256_GraphMatrix.cpp(邻接矩阵)和 p258_GraphAdjoin.cpp(邻接表)源程序，读懂程序完成空缺部分代码。 三. 函数的功能说明及算法思路 （包括每个函数的功能说明，及一些重要函数的算法实现思路） 四. 实验结果与分析 （包括运行结果截图、结果分析等）

五.心得体会

程序比较难写，但是可以通过之前的一些程序来找到一些规律 （记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。） 【附录----源程序】 256: //p-255 图的存储结构以数组邻接矩阵表示, 构造图的算法。 #include #include #include #include typedef char VertexType; //顶点的名称为字符 const int MaxVertexNum=10; //图的最大顶点数 const int MaxEdgeNum=100; //边数的最大值 typedef int WeightType; //权值的类型 const WeightType MaxValue=32767; //权值的无穷大表示 typedef VertexType Vexlist[MaxVertexNum]; //顶点信息，定点名称 typedef WeightType AdjMatrix[MaxVertexNum][MaxVertexNum]; //邻接矩阵typedef enum{DG,DN,AG,AN} GraphKind; //有向图,有向网,无向图,无向网typedef struct{ Vexlist vexs; // 顶点数据元素 AdjMatrix arcs; // 二维数组作邻接矩阵 int vexnum, arcnum; // 图的当前顶点数和弧数 GraphKind kind; // 图的种类标志 } MGraph; void CreateGraph(MGraph &G, GraphKind kd)// 采用数组邻接矩阵表示法，构造图G {//构造有向网G int i,j,k,q; char v, w; G.kind=kd; //图的种类 printf("输入要构造的图的顶点数和弧数：\n"); scanf("%d,%d",&G.vexnum,&G.arcnum); getchar();//过滤回车 printf("依次输入图的顶点名称ABCD...等等：\n"); for (i=0; i

数据结构实验报告--图实验

图实验 一，邻接矩阵的实现 1.实验目的 （1）掌握图的逻辑结构 （2）掌握图的邻接矩阵的存储结构 （3）验证图的邻接矩阵存储及其遍历操作的实现 2.实验内容 （1）建立无向图的邻接矩阵存储 （2）进行深度优先遍历 （3）进行广度优先遍历 3．设计与编码 MGraph.h #ifndef MGraph_H #define MGraph_H const int MaxSize = 10; template class MGraph { public: MGraph(DataType a[], int n, int e); ~MGraph(){ } void DFSTraverse(int v); void BFSTraverse(int v); private: DataType vertex[MaxSize]; int arc[MaxSize][MaxSize]; int vertexNum, arcNum; }; #endif MGraph.cpp #include using namespace std; #include "MGraph.h" extern int visited[MaxSize]; template MGraph::MGraph(DataType a[], int n, int e)

{ int i, j, k; vertexNum = n, arcNum = e; for(i = 0; i < vertexNum; i++) vertex[i] = a[i]; for(i = 0;i < vertexNum; i++) for(j = 0; j < vertexNum; j++) arc[i][j] = 0; for(k = 0; k < arcNum; k++) { cout << "Please enter two vertexs number of edge: "; cin >> i >> j; arc[i][j] = 1; arc[j][i] = 1; } } template void MGraph::DFSTraverse(int v) { cout << vertex[v]; visited[v] = 1; for(int j = 0; j < vertexNum; j++) if(arc[v][j] == 1 && visited[j] == 0) DFSTraverse(j); } template void MGraph::BFSTraverse(int v) { int Q[MaxSize]; int front = -1, rear = -1; cout << vertex[v]; visited[v] = 1; Q[++rear] = v; while(front != rear) { v = Q[++front]; for(int j = 0;j < vertexNum; j++) if(arc[v][j] == 1 && visited[j] == 0){ cout << vertex[j]; visited[j] = 1;

数据结构C语言版 串的定长顺序存储表示和实现

#include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define MAXSTRLEN 255 typedef int ElemType; typedef int Status; typedef unsigned char SString[MAXSTRLEN+1]; //串赋值操作 Status StrAssign(SString T,char chars[]){ // 生成一个其值等于chars的串T int i; if(strlen(chars)>MAXSTRLEN) return ERROR; T[0]=strlen(chars); for(i=0;i<=T[0];i++){ T[i+1]=chars[i];} return OK; }//StrAssign //输出串 void StrPrint(SString S){ int i; for(i=1;i<=S[0];i++){ printf("%c",S[i]); } printf("\n"); }//PrnStr //串复制操作 Status StrCopy(SString T,SString S){ // 由串S复制得串T int i; for(i=1;i<=S[0];i++) T[i]=S[i]; T[0]=S[0]; return OK; }//StrCopy //判空操作 Status StrEmpty(SString S){ if(S[0]==0) return OK;

数据结构图的存储结构及

数据结构图的存储结构及基本操作

1.实验目的 通过上机实验进一步掌握图的存储结构及基本操作的实现。 2.实验内容与要求 要求： ⑴能根据输入的顶点、边/弧的信息建立图； ⑵实现图中顶点、边/弧的插入、删除； ⑶实现对该图的深度优先遍历； ⑷实现对该图的广度优先遍历。 备注：单号基于邻接矩阵，双号基于邻接表存储结构实现上述操作。 3.数据结构设计 逻辑结构：图状结构 存储结构：顺序存储结构、链式存储结构 4.算法设计 #include #include #include #define MAX_VERTEX_NU M 20 typedef struct ArcNode { int adjvex; struct ArcNode *nextarc;

}ArcNode; typedef struct VNode { char data[2]; //顶点就设置和书上V1等等一样吧 ArcNode *firstarc; }VNode,AdjList[MAX _VERTEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; }ALGraph; typedef struct { int data[MAX_VERTEX_ NUM+10]; int front; int rear; }queue; int visited[MAX_VERTE X_NUM]; queue q; int main() { ALGraph G; int CreateUDG(ALGraph &G); int DeleteUDG(ALGraph &G); int InsertUDG(ALGraph &G); void BFSTraverse(ALGrap h G, int (*Visit)(ALGraph

数据结构实验报告-顺序表的创建、遍历及有序合并操作

数据结构实验报告-顺序表的创建、遍历及有序合并操作二、实验内容与步骤 实现顺序表的创建、遍历及有序合并操作，基本数据结构定义如下： typedef int ElemType; #define MAXSIZE 100 #define FALSE 0 #define TRUE 1 typedef struct {ElemType data[MAXSIZE]; int length; }seqlist; 创建顺序表，遍历顺序表 #include #include #define MAXSIZE 100 #define Icreament 20 #define FALSE 0

#define TRUE 1 typedef int ElemType; //用户自定义数据元素类型 // 顺序表结构体的定义 typedef struct { ElemType *elem; //顺序表的基地址 int length; //顺序表的当前长度 int listsize; //预设空间容量 }SqList; //线性表的顺序存储结构 SqList* InitList() //创建空的顺序表 { SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表L if(!L) { printf("空间划分失败，程序退出\n"); return NULL; } L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType)); if(!L->elem) { printf("空间划分失败，程序退出\n");

C# SQLite数据库 访问封装类资料

C# SQLite数据库访问封装类 C# 异常处理（Catch Throw）IL分析在客户端配置文件节点下，添加：[html] view plain copy 在CODE上查看代码片派生到我的代码片 其中【localdb】是本地SQLite数据库的名称，【config/local.db】是在当前程序运行目录下SQLite数据库位置 C# SQLite数据库访问封装类代码： [csharp] view plain copy 在CODE上查看代码片派生到我的代码片 ///

/// 本类为SQLite数据库帮助静态类,使用时只需直接调用即可,无需实例化 ///

public static class SQLiteHelper { // Application.StartupPath public static string LocalDbConnectionString = ConfigurationManager.ConnectionStrings["localdb"].ConnectionString; #region ExecuteNonQuery ///

/// 执行数据库操作(新增、更新或删除) ///

/// 连接字符串 /// SqlCommand对象 /// 所受影响的行数 public static int ExecuteNonQuery(string connectionString, SQLiteCommand cmd) { int result = 0; if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); using (SQLiteConnection con = new SQLiteConnection(connectionString)) { SQLiteTransaction trans = null; PrepareCommand(cmd, con, ref trans, true, https://www.wendangku.net/doc/d013864519.html,mandType, https://www.wendangku.net/doc/d013864519.html,mandText); try { result = cmd.ExecuteNonQuery(); https://www.wendangku.net/doc/d013864519.html,mit(); }

数据结构图实验报告

数据结构教程 上机实验报告 实验七、图算法上机实现 一、实验目的： 1.了解熟知图的定义和图的基本术语，掌握图的几种存储结构。 2.掌握邻接矩阵和邻接表定义及特点，并通过实例解析掌握邻接矩阵和邻接表的类型定义。 3.掌握图的遍历的定义、复杂性分析及应用，并掌握图的遍历方法及其基本思想。 二、实验内容： 1.建立无向图的邻接矩阵 2.图的xx优先搜索 3.图的xx优先搜索 三、实验步骤及结果： 1.建立无向图的邻接矩阵： 1)源代码： #include "stdio.h" #include "stdlib.h" #define MAXSIZE 30 typedefstruct{charvertex[MAXSIZE];//顶点为字符型且顶点表的长度小于MAXSIZE intedges[MAXSIZE][MAXSIZE];//边为整形且edges为邻近矩阵

}MGraph;//MGraph为采用邻近矩阵存储的图类型 voidCreatMGraph(MGraph *g,inte,int n) {//建立无向图的邻近矩阵g->egdes，n为顶点个数，e为边数inti,j,k; printf("Input data of vertexs(0~n-1): \n"); for(i=0;ivertex[i]=i; //读入顶点信息 for(i=0;iedges[i][j]=0; //初始化邻接矩阵 for(k=1;k<=e;k++)//输入e条边{}printf("Input edges of(i,j): "); scanf("%d,%d",&i,&j); g->edges[i][j]=1; g->edges[j][i]=1;}void main(){inti,j,n,e; MGraph *g; //建立指向采用邻接矩阵存储图类型指针 g=(MGraph*)malloc(sizeof(MGraph));//生成采用邻接举证存储图类型的存储空间}2)运行结果： printf("Input size of MGraph: "); //输入邻接矩阵的大小scanf("%d",&n); printf("Input number of edge: "); //输入邻接矩阵的边数scanf("%d",&e);

数据结构与算法-实现顺序表的基本操作

实验报告 课程：数据结构与算法实验日期： 实验名称：实现顺序表的基本操作 一、实验目的 实现顺序表的熟练操作 二、实验内容 （1）先给出顺序表的类型定义 （2）给出顺序表的如下基本操作的算法函数定义 a) 构造一个空的线性表：InitList_Sq(SqList &L) b) 在顺序表L的第i个位置之前插入新的元素e：ListInsert_Sq(SqList &L, int i, ElemType e) c) 在顺序表L中删除第i个元素，并用e返回其值：ListDelete_Sq(SqList &L, int i, ElemType &e) （3）实现如下新操作的函数定义： a) 借助ListInsert_Sq操作创建一个顺序表：ListCreate_Sq(???) b) 计算线性表的长度：ListLength_Sq(???) c) 打印顺序表中的所有元素值：ListPrint_Sq(???) 其中???请自行考虑 （4）在主函数中分别调用ListCreate_Sq、ListPrint_Sq 、ListLength_Sq、ListInsert_Sq、ListDelete_Sq等函数，查看这些函数是否正常工作 三、实验步骤 （1）先给出顺序表的类型定义 （2）给出顺序表的如下基本操作的算法函数定义 a) 构造一个空的线性表：InitList_Sq(SqList &L)

b) 在顺序表L的第i个位置之前插入新的元素e：ListInsert_Sq(SqList &L, int i, ElemType e) c) 在顺序表L中删除第i个元素，并用e返回其值：ListDelete_Sq(SqList &L, int i, ElemType &e)