数据结构实验抽象数据类型——复数运算报告

实验一复数四则运算一、实验目的本次实验的主要目的在于帮助读者熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现，即利用高级程序设计语言中已存在的数据类型来说明新的结构,用已经实现的操作来组合新的操作，具体实现细节则依赖于所用语言的功能.通过本次实习还可以帮助读者复习高级语言的使用方法.二、实验内容设计一个可进行复数运算的演示程序。

要求实现下列六种基本运算：1)由输入的实部和虚部生成一个复数;２）两个复数求和;3)两个复数求差；４)两个复数求积,5）从已知复数中分离出实部；6)从已知复数中分离出虚部。

运算结果以相应的复数或实数的表示形式显示。

三、实验仪器、设备及材料５８６以上微机四、实验原理复数在计算机中的表示及复数的四则运算规则.五、实验步骤１。

问题分析和任务定义；2。

数据类型和系统设计；３. 编码实现和静态检查;4。

上机准备和上机调试；5．总结和整理实验报告。

六、实验报告要求实验报告开头就给出题目、班级、姓名、学号和完成日期,并包括以下七个内容：１. 需求分析；2．概要设计;３．详细设计;4. 调试分析；5。

经验和体会等;6。

测试结果;７.附录。

七、实验注意事项实验前先预习，完成问题分析和任务定义的工作。

实验二集合的并、交和差运算一、实验目的本次实验的主要目的在于帮助学生熟练掌握线性表的基本操作在两种存储结构上的实现，其中以各种链表的操作和应用作为重点内容.二、实验内容编制一个能演示执行集合的并、交和差运算的程序。

三、实验仪器、设备及材料586以上微机四、实验原理利用链表的基本运算（插入、删除、查找及合并等)实现集合的基本运算。

五、实验步骤1。

问题分析和任务定义;２．数据类型和系统设计；3。

编码实现和静态检查;4。

上机准备和上机调试；5。

总结和整理实验报告。

六、实验报告要求实验报告开头就给出题目、班级、姓名、学号和完成日期,并包括以下七个内容：1．需求分析；２。

概要设计；3．详细设计；４．调试分析；5. 经验和体会等;６．测试结果；7. 附录。

C++实现复数加减乘除实验报告实验 C++实现复数的加减乘除试用C语言的结构类型定义表示复数Complex的抽象数据类型。

（1）在复数内部用浮点数定义其实部与虚部；（2）设计实现复数的＋、－、×、÷等运算的函数。

基本操作函数接口：InitComplex( &Z, v1, v2 )：操作结果：构造复数Z,其实部和虚部分别被赋以参数v1和v2的值。

GetReal( Z, &realPart )：初始条件：复数已存在。

操作结果：用realPart返回复数Z的实部值。

GetImag( Z, &ImagPart )：初始条件：复数已存在。

操作结果：用ImagPart返回复数Z的虚部值。

Add( z1,z2, ∑ )：初始条件：z1,z2是复数。

操作结果：用sum返回两个复数z1,z2的和值。

Sub( z1,z2, &residue)：初始条件：z1,z2是复数。

操作结果：用res返回两个复数z1,z2的差值。

mul( z1,z2, &product )：初始条件：z1,z2是复数。

操作结果：用product返回两个复数z1,z2的积。

div( z1,z2, &quotient,&residue)：初始条件：z1,z2是复数。

操作结果：用quotient 返回两个复数z1除z2的商，用residue 返回它们的余数。

要求main函数中只能是基本的输入输出语句和函数调用语句，其运行界面如下：please input first complex number : a + bithe other one : c+ diplease choice operation: +, -, * or /:+(a + bi)+ (c+ di)=……其中a,b,c,d是用户从键盘上输入的实型值，分别代表两个复数的实部和虚部。

实验代码：#include //定义一个复数类typedef struct {float realpart;float imagpart;}Complex;Complex InitComplex(float v1,float v2) //初始化{ Complex z;z.realpart=v1;z.imagpart=v2;return z;}float Getreal(Complex z){return z.realpart;}float Getimagepart(Complex z){return z.imagpart;}Complex Add(Complex z1,Complex z2) //实现加法运算{z1.realpart=z1.realpart+z2.realpart;z1.imagpart=z1.imagpart+z2.imagpart;return z1;}Complex Sub(Complex z1,Complex z2) //实现减法运算{z1.realpart=z1.realpart-z2.realpart;z1.imagpart=z1.imagpart-z2.imagpart;return z1;}Complex Mul(Complex z1,Complex z2) //实现乘法运算{z1.realpart=z1.realpart*z2.realpart;z1.imagpart=z1.imagpart*z2.imagpart;return z1;}Complex Div(Complex z1,Complex z2) // 实现除法运算{z1.realpart=z1.realpart/z2.realpart;z1.imagpart=z1.imagpart/z2.imagpart;return z1;}int main (){ float a,b,c,d;char e;Complex z1,z2,z3;printf("please input first complex number a+bi:"); //只需输入实部a,虚部b scanf("%f %f",&a,&b);z1= InitComplex(a,b);printf("please input the other :");scanf("%f %f",&c,&d);z2=InitComplex(c,d);printf("please choice operation :+，-,*,/ :"); //选择运算符getchar();scanf("%c",&e);if (e=='+') //选择运算符z3= Add( z1,z2);if(e=='-')z3=Sub(z1,z2);if(e=='*')z3=Mul(z1,z2);if(e=='/')z3=Div(z1, z2);printf("%f+%fi",z3.realpart,z3.imagpart); return 0;}运行结果:。

数据结构第一章复数实验总结数据结构是计算机科学中非常重要的一门课程，它研究的是数据的组织、存储和管理方法，以及不同数据之间的关系和操作。

在数据结构的第一章中，我们学习了复数的基本概念和运算，本文将对这一章的内容进行总结和归纳。

我们需要明确什么是复数。

复数是由实数和虚数部分组成的数，通常表示为a+bi的形式，其中a是实部，b是虚部，i是虚数单位。

在数据结构中，复数通常被用来表示坐标系中的点或者向量，可以进行加、减、乘、除等运算。

在第一章的学习中，我们了解到复数有很多重要的性质和运算规则。

首先，复数的共轭是指将复数的虚部取相反数，实部保持不变。

共轭的概念在复数的运算中非常重要，可以用来简化复数的乘法和除法运算。

其次，复数的模是指复数与原点的距离，可以用勾股定理计算。

模的平方可以表示复数的乘法运算结果的绝对值。

在进行复数的运算时，我们需要注意一些规则和性质。

首先，复数的加法和减法是按照实部和虚部分别进行计算的，即实部相加减，虚部相加减。

其次，复数的乘法是按照分配律和共轭的性质进行计算的，即实部相乘减虚部相乘。

最后，复数的除法是通过将除数和被除数同时乘以除数的共轭，然后按照乘法的规则进行计算得到的。

除了基本的运算规则之外，我们还学习了一些重要的性质和定理。

例如，复数的乘法满足交换律和结合律。

同时，我们还学习了欧拉公式和德莫佛公式，它们可以将复数表示为指数形式，方便进行后续的运算。

此外，我们还学习了复数的幂运算和根运算，它们可以通过欧拉公式和德莫佛公式进行简化和求解。

在实际应用中，复数常常用于描述和计算电路中的交流信号、傅里叶变换以及图像处理等领域。

通过使用复数，我们可以更方便地进行计算和分析，简化了问题的求解过程。

例如，在信号处理中，我们可以通过复数来表示频率和相位，进行滤波和频谱分析。

在图像处理中，我们可以利用复数进行傅里叶变换和反变换，实现图像的压缩和增强等操作。

数据结构第一章的复数实验使我们了解了复数的基本概念、运算规则和性质。

第1篇一、实验目的1. 理解复数的概念及其在数学和物理中的应用。

2. 掌握复数的四则运算规则，包括加法、减法、乘法和除法。

3. 熟悉复数在计算机编程中的应用，如复数类的实现。

4. 通过实验加深对复数运算原理的理解。

二、实验原理复数是数学中的一个重要概念，它由实部和虚部组成，形式为 a + bi，其中 a 和b 是实数，i 是虚数单位，满足i² = -1。

复数在数学、物理、工程等领域有广泛的应用，如电路分析、信号处理等。

复数的四则运算规则如下：1. 加法：两个复数相加，将它们的实部和虚部分别相加，即 (a + bi) + (c + di) = (a + c) + (b + d)i。

2. 减法：两个复数相减，将它们的实部和虚部分别相减，即 (a + bi) - (c + di) = (a - c) + (b - d)i。

3. 乘法：两个复数相乘，使用分配律和虚数单位 i 的性质，即 (a + bi)(c + di) = ac + adi + bci + bdi² = (ac - bd) + (ad + bc)i。

4. 除法：两个复数相除，先将除数乘以共轭复数，然后实部和虚部分别相除，即(a + bi) / (c + di) = [(a + bi)(c - di)] / [(c + di)(c - di)] = [(ac + bd) + (bc - ad)i] / (c² + d²)。

三、实验内容1. 复数的加法：编写程序实现两个复数的加法运算。

2. 复数的减法：编写程序实现两个复数的减法运算。

3. 复数的乘法：编写程序实现两个复数的乘法运算。

4. 复数的除法：编写程序实现两个复数的除法运算。

5. 复数类的实现：使用面向对象编程方法，实现一个复数类，包含加法、减法、乘法和除法方法。

四、实验步骤1. 加法运算：- 输入两个复数的实部和虚部。

- 计算它们的和，输出结果。

复数adt及其实现实验报告ADT（Abstract Data Type）即抽象数据类型，是一种描述数据对象和操作对象的数学模型。

它定义了数据对象的抽象特性和对其的操作，而不考虑其在计算机内部的表示和实现细节。

ADT的设计和实现对于编程的重要性不言而喻，因此本文将以复数ADT为例，详细介绍ADT的实现过程。

一、复数ADT的定义复数ADT可以定义为包含实部和虚部的数学对象。

我们可以对复数进行加减乘除等操作，并可以获取其实部和虚部的值。

二、复数ADT的操作1. 创建复数：创建一个复数对象，并初始化其实部和虚部的值。

2. 获取实部和虚部：返回复数对象的实部和虚部的值。

3. 设置实部和虚部：设置复数对象的实部和虚部的值。

4. 复数相加：将两个复数相加，并返回相加后的复数。

5. 复数相减：将两个复数相减，并返回相减后的复数。

6. 复数相乘：将两个复数相乘，并返回相乘后的复数。

7. 复数相除：将两个复数相除，并返回相除后的复数。

三、复数ADT的实现我们可以使用面向对象的思想来实现复数ADT。

首先，我们定义一个复数类（Complex），其中包含私有变量real和imag，分别表示复数的实部和虚部。

pythonclass Complex:def __init__(self, real, imag):self.real = realself.imag = imagdef get_real(self):return self.realdef get_imag(self):return self.imagdef set_real(self, real):self.real = realdef set_imag(self, imag):self.imag = imagdef add(self, other):real = self.real + other.realimag = self.imag + other.imagreturn Complex(real, imag)def subtract(self, other):real = self.real - other.realimag = self.imag - other.imagreturn Complex(real, imag)def multiply(self, other):real = self.real * other.real - self.imag * other.imagimag = self.real * other.imag + self.imag * other.realreturn Complex(real, imag)def divide(self, other):denominator = other.real 2 + other.imag 2real = (self.real * other.real + self.imag * other.imag) / denominatorimag = (self.imag * other.real - self.real * other.imag) / denominatorreturn Complex(real, imag)四、复数ADT的使用示例python创建两个复数对象c1 = Complex(1, 2)c2 = Complex(3, 4)获取实部和虚部的值print(c1.get_real) 输出：1 print(c1.get_imag) 输出：2 设置实部和虚部的值c1.set_real(5)c1.set_imag(6)print(c1.get_real) 输出：5 print(c1.get_imag) 输出：6 复数相加c3 = c1.add(c2)print(c3.get_real) 输出：8 print(c3.get_imag) 输出：10 复数相减c4 = c1.subtract(c2)print(c4.get_real) 输出：-2 print(c4.get_imag) 输出：-2 复数相乘c5 = c1.multiply(c2)print(c5.get_real) 输出：-5 print(c5.get_imag) 输出：28 复数相除c6 = c1.divide(c2)print(c6.get_real) 输出：0.44print(c6.get_imag) 输出：0.08通过上述示例，我们可以看到复数ADT的实现过程。

【实验题目】实验1. 抽象数据类型. 【问题描述】用C 或C++语言设计并实现一个可进行复数运算的演示程序。

【基本要求】1.由输入的实部和虚部生成一个复数2.两个复数求和3.两个复数求差4.从已知复数中分离出实部和虚部5.复数及相应运算结果以相应的表现形式显示。

【实现提示】定义复数为由两个相互之间存在次序关系的实数构成的抽象数据类型，则可以利用实数的操作来实现复数的操作。

（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四） 一、【实验构思（Conceive ）】(10%)（本部分应包括：描述实验实现的基本思路，包括所用到的离散数学、工程数学、程序设计、算法等相关知识）1. 首先构造结构体数组接受储存数据2. 构造函数进行模块运算3. 应用到了算法中的抽象数据类型ADT （即数据+操作），数据部分包括实部和虚部；操作部分包括加分Plus 、减法Minus 、乘法Multiply 、除法Divide 4. 运用到了复数的基本知识及四则运算法则：设 z 1=a + bi ，z 2=c + di ，（a ，b ，c ，d ∈R ，）加减法：（a + bi ）±（c + di ）=（a ± c ）+（b ± d ）i 乘法：（a + bi ）*（c + di ）=（ac - bd ）+（ad + bc ）i除法： 2222()()()()a bi a bi c di ac bd bc ad ic di cd c d++-+-==+++ 二、【实验设计(Design)】(15%) （本部分应包括：抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明，主程序模块与各子程序模块间的调用关系） 解答：抽象数据类型 数据部分：用结构体（数组）实现复数的储存结构 操作部分：实现复数的输入、存储、运算及输出 程序模块伪码说明： #define N 2int n=0; //控制选择语句，及检验输入是否正确 typedef struct{double real;//复数的实部double imag;//复数的虚部}paramater; //paramater是结构体变量的类型表示“复数”，声明复数的存储结构paramater cpxNum[N];//构造结构体数组储存数据paramater result;//构造result结构体储存结果int main(){//实现第一个复数的输入储存cout<<"\t请输入第一个复数的实部和虚部:";cin>>real>>imag;outs(c[0].real,c[0].imag)//初始化复数c[0]并实现输出//实现第二个复数的输入储存cout<<"\t请输入第二个复数的实部和虚部:";cin>>real>>imag;puts( c[0].real,c[0].imag);//初始化复数c[1]并实现输出//复数运算cout << "c1 + c2的结果是: "; puts(plus(c[0],c[1])); cout << endl; //调用plus函数运算加法，再用puts函数输出结果复数cout << "c1 - c2的结果是: "; puts(milus(c[0],c[1])); cout << endl; //调用mlius函数运算减法，再用puts函数输出结果复数cout << "c1 * c2的结果是: "; puts(multiply(c[0],c[1])); cout << endl; //调用multiply函数运算乘法，再用puts函数输出结果复数cout << "c1 / c2的结果是: "; puts(divide(c[0],c[1])); cout << endl; //调用divide函数运算除法，再用puts函数输出结果复数return 0;}三、【实现描述（Implement）】(25%)（本部分应包括：抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系，关键的程序流程图等，给出关键算法的时间复杂度分析。

实验名称：复数的运算实验目的：1. 理解复数的概念及其几何意义。

2. 掌握复数的加减、乘除运算方法。

3. 熟悉复数的模和辐角的概念及计算方法。

实验器材：1. 计算器2. 复数坐标纸3. 铅笔实验原理：复数是数学中的一个重要概念，它可以表示平面上的点。

一个复数通常用a+bi表示，其中a是实部，b是虚部，i是虚数单位，满足i²=-1。

复数在几何上对应于平面直角坐标系中的一个点，其实部对应横坐标，虚部对应纵坐标。

实验步骤：1. 观察复数坐标纸，了解复数在坐标系中的表示方法。

2. 用计算器验证以下复数运算：（1）加减运算：计算复数（3+4i）和（2-5i）的和与差。

（2）乘除运算：计算复数（3+4i）和（2-5i）的乘积和商。

3. 用复数坐标纸表示计算结果，观察几何意义。

4. 计算复数（3+4i）的模和辐角。

5. 分析复数模和辐角的计算方法。

实验结果：1. 复数加减运算：和：3+4i + 2-5i = 5-1i差：3+4i - 2+5i = 1+9i2. 复数乘除运算：乘积：（3+4i）×（2-5i）= -7-2i商：（3+4i）÷（2-5i）= 0.8+1.6i3. 复数坐标纸表示：和：5-1i 对应点（5，-1）差：1+9i 对应点（1，9）乘积：-7-2i 对应点（-7，-2）商：0.8+1.6i 对应点（0.8，1.6）4. 复数（3+4i）的模和辐角：模：|3+4i| = √(3²+4²) = 5辐角：θ = arctan(4/3) ≈ 0.927弧度实验分析：1. 复数的加减运算遵循实部和虚部分别相加或相减的规则。

2. 复数的乘除运算可以转化为实部和虚部的乘除运算，同时注意虚数单位i的运算。

3. 复数的模表示复数在复平面上的长度，辐角表示复数与实轴的夹角。

4. 通过实验，我们可以直观地了解复数在复平面上的几何意义，以及复数运算的规律。

实验结论：通过本次实验，我们掌握了复数的概念、几何意义以及加减、乘除运算方法。

韶关学院学生实验报告册实验课程名称：数据结构与算法实验项目名称：实验一抽象数据类型复数四则运算实验类型（打√）：（基础、综合、设计√）院系：信息工程学院计算机系专业：*****姓名：*** 学号：*****指导老师：陈正铭韶关学院教务处编制一、实验预习报告内容二、实验原始（数据）记录实验时间：2007 年 3 月21 日（星期三第7，8 节）实验同组人：三、实验报告内容2007年 3 月21 日注：1、如有个别实验的实验报告内容多，实验报告册页面不够写，或有识图，画图要求的，学生应根据实验指导老师要求另附相同规格的纸张并粘贴在相应的“实验报告册”中。

2、实验报告册属教学运行材料，院系（中心）应按有关规定归档保管。

【源程序】#include<stdio.h>#include<stdlib.h>typedef struct Complex{float real;float image;}Complex;Complex InitComplex(float a,float b) /*给复数的实部和虚部复制，并返回复数。

*/ {Complex c;c.real=a;c.image=b;return c;}Complex Add(Complex c1,Complex c2){/*两个复数相加。

公式：(a+bi)+(c+di)=(a+b)+(c+d)i。

*/Complex sum;sum.real=c1.real+c2.real ;sum.image=c1.image+c2.image ;return sum;}Complex Sub(Complex c1,Complex c2){/*两个复数相减。

公式：(a+bi)-(c+di)=(a-b)+(c-d)i。

*/Complex dif;dif.real=c1.real-c2.real ;dif.image=c1.image-c2.image ;return dif;}Complex Mul(Complex c1,Complex c2){/*两个复数相乘。

复数的运算实验报告一、实验要求：设计题：设计一个可进行复数运算的演示程序。

基本要求：实现以下四种基本运算：1）由输入的实部和虚部生成一个复数。

2）两个复数求和3）两个复数求差4）两个复数求积运算结果以相应的复数或实数的表示形式显示二、实验思路：1、设计一个复数数据类型；2、设计函数复数初始化函数initcpx(complex &y,float m,float n), 复数输出函数cpxprint(complex a), 复数求和函数sumcpx(complex&b,complex b1,complex b2 ), 复数求差函数subcpx(complex &c,complexc1,complex c2),复数乘积函数mltcpx(complex &d,complex d1,complexd2)三、源代码：#include<stdio.h>typedef struct complex{float realprt;float imgprt;}complex;void initcpx(complex &y,float m,float n){y.realprt=m;y.imgprt=n;}void cpxprint(complex a){if (a.realprt==0.0)printf("复数是：%5.2fi",a.imgprt);elseprintf("复数是：%5.2f+%5.2fi",a.realprt,a.imgprt);}void sumcpx(complex &b,complex b1,complex b2 ){b.realprt=b1.realprt+b2.realprt;b.imgprt=b1.imgprt+b2.imgprt;printf("复数的和为：%5.2f+%5.2fi",b.realprt,b.imgprt); }void subcpx(complex &c,complex c1,complex c2) {c.realprt=c1.realprt-c2.realprt;c.imgprt=c1.imgprt-c2.imgprt;printf("复数的差是：%5.2f+%5.2fi",c.realprt,c.imgprt); }void mltcpx(complex &d,complex d1,complex d2) {d.realprt=d1.realprt*d2.realprt-d1.imgprt*d2.imgprt;d.imgprt=d1.realprt*d2.imgprt+d1.imgprt*d2.realprt; printf("复数的积是：%5.2f+%5.2fi",d.realprt,d.imgprt); }void main(){float a,b,c,d;complex x1,x2,sum,sub,mlt;printf("输入第一个复数的实部：\n");scanf("%f",&a);printf("输入复数的虚部：\n");scanf("%f",&b);initcpx(x1,a,b);printf("第一个复数是：\n");cpxprint(x1);printf("\n");printf("\n");printf("输入第二个复数的实部：\n");scanf("%f",&c);printf("输入复数的虚部：\n");scanf("%f",&d);initcpx(x2,c,d);printf("第二个复数是：\n");cpxprint(x2);printf("\n");printf("\n");sumcpx(sum,x1,x2);printf("\n"); subcpx(sub,x1,x2); printf("\n"); mltcpx(mlt,x1,x2); printf("\n");printf("\n");}四、实验结果：。

实验报告一、实验题目[问题描述]设计一个可进行复数运算的演示程序。

[基本要求]实现下列六种基本运算：1）由输入的实部和虚部生成一个复数2）两个复数求和3）两个复数求差4）两个复数求积5）从已知复数中分离出实部6）从已知复数中分离出虚部运算结果以相应的复数或实数的表示形式显示。

二、概要设计1．定义复数类型：ADT Complex{数据对象：D={c i|c i=(real,image),real∈实数，image∈实数，i=1,2,3,…} 数据关心：R1={}基本操作：C_Sum(&C,C1,C2)初始条件：复数C1,C2存在。

操作结果：做和运算C1+C2，结果放在C中。

C_Difference(&C，C1,C2)初始条件：复数C1,C2存在。

操作结果：做减运算C1-C2，结果放在C中。

C_Product(&C,C1,C2)初始条件：复数C1,C2存在。

操作结果：做乘运算C1*C2，结果放在C中。

C_Print(C)初始条件：复数C存在。

操作结果：将复数C以“实部+虚部i”的形式显示输出。

}ADT Complex2.程序包含四个模块○1主程序模块main(){初始化；选择命令；while(“命令”!=“退出”){处理命令；}}○2两复数求和模块○3两复数求差模块○4两复数求积模块○5打印复数模块3.程序流程图三、详细设计1.复数数据类型typedef struct{float real;float image;}complex,*complex_ptr;void C_Difference(complex_ptr C,complex C1,complex C2) //将复数C1,C2相减，结果放入复数指针C所指向的复数单元中去。

void C_Product(complex_ptr C,complex C1,complex C2)//将复数C1,C2相乘，结果放入复数指针C所指向的复数单元中去。

一、实验目的1. 理解复数的概念及其表示方法。

2. 掌握复数的加、减、乘、除等基本运算。

3. 运用复数运算解决实际问题。

二、实验原理复数是由实部和虚部组成的数，表示为a+bi，其中a为实部，b为虚部，i为虚数单位，满足i^2=-1。

复数运算遵循以下规则：1. 加法：a+bi + c+di = (a+c) + (b+d)i2. 减法：a+bi - c+di = (a-c) + (b-d)i3. 乘法：(a+bi) × (c+di) = (ac-bd) + (ad+bc)i4. 除法：(a+bi) ÷ (c+di) = [(ac+bd) + (bc-ad)i] ÷ (c^2+d^2)三、实验仪器与材料1. 计算器2. 笔3. 纸四、实验步骤1. 实验一：复数的加法与减法（1）取两个复数：2+3i和4-5i。

（2）计算它们的和：2+3i + 4-5i = (2+4) + (3-5)i = 6-2i。

（3）计算它们的差：2+3i - 4-5i = (2-4) + (3+5)i = -2+8i。

2. 实验二：复数的乘法（1）取两个复数：3+4i和2-3i。

（2）计算它们的乘积：3+4i × 2-3i = (3×2-4×3) + (3×(-3)+4×2)i = -3+2i。

3. 实验三：复数的除法（1）取两个复数：4+3i和2-i。

（2）计算它们的商：4+3i ÷ 2-i = [(4+3i)×(2+i)] ÷ [(2-i)×(2+i)] = (8+10i-3) ÷ (4+1) = 5+2.5i。

五、实验结果与分析1. 通过实验一，我们掌握了复数的加法与减法运算，可以得出结论：复数加法与实数加法类似，只需将实部与虚部分别相加；复数减法只需将减数的实部与虚部分别减去被减数的实部与虚部。

云南大学软件学院数据结构实验报告指导教师： 2009秋季学期学号：20081120064 姓名：李雪寒【实验题目】实验1. 抽象数据类型.【问题描述】用C或C++语言设计并实现一个可进行复数运算的演示程序。

【基本要求】1.由输入的实部和虚部生成一个复数2.两个复数求和3.两个复数求差4.从已知复数中分离出实部和虚部5.复数及相应运算结果以相应的表现形式显示。

【实现提示】定义复数为由两个相互之间存在次序关系的实数构成的抽象数据类型，则可以利用实数的操作来实现复数的操作。

一、【概要设计】熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现，即利用处理器中已存在的数据类型来说明新的结构，用已经实现的操作来组合新的操作。

抽象数据类型可以使我们更容易描述现实世界。

例：用线性表描述学生成绩表，用树或图描述遗传关系。

对一个抽象数据类型进行定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定这些函数的参数性质。

一旦定义了一个抽象数据类型及具体实现，程序设计中就可以像使用基本数据类型那样，十分方便地使用抽象数据类型。

抽象数据类型的描述包括给出抽象数据类型的名称、数据的集合、数据之间的关系和操作的集合等方面的描述。

主程序模块：printf("请输入第一个复数的实部和虚部，中间以空格隔开：");scanf("%f %f",&a,&b);printf("请输入第二个复数的实部和虚部，中间以空格隔开：");scanf("%f %f",&c,&d);/*输入两个复数的实部和虚部*/CreatComplex(c1,a,b);PrintComplex(c1);Printreal(c1);Printimage(c1);CreatComplex(c2,c,d);PrintComplex(c2);Printreal(c2);Printimage(c2);/*通过调用CreatComplex(),PrintComplex(),Printreal(),printimage()函数，用输入的实部和虚部生成复数并输出出来，再从中分离出实部和虚部*/AddComplex(Sum,c1,c2);PrintComplex(Sum);/*求和*/SubComplex(Sub,c1,c2);PrintComplex(Sub);/*求差*/MulComplex(Mul,c1,c2);PrintComplex(Mul);/*求积*/}子程序模块：void CreatComplex(Complex& c,float a,float b){c.real = a;c.image = b;} /*构造复数，包括实部和虚部*/void AddComplex(Complex& sum,Complex c1,Complex c2){sum.real = c1.real + c2.real ;sum.image = c1.image + c2.image ;} /*求和*/void SubComplex(Complex& Sub,Complex c1,Complex c2 ){Sub.real = c1.real -c2.real ;Sub.image = c1.image - c2.image ;}/*求差*/void MulComplex(Complex& Mul,Complex c1,Complex c2 ){Mul.real = c1.real * c2.real - c1.image * c2.image ;Mul.image = c1.real * c2.image + c1.image * c2.real ;}/*求积*/void PrintComplex(Complex c){if (c.image == 0.0)printf("%5.2f\n",c.real );/*所要输出的复数虚部为零时的情况*/else{if(c.real==0.0)printf("%5.2fi\n",c.image); /*所要输出的复数实部为零时的情况*/elseprintf("%5.2f+%5.2fi\n",c.real ,c.image ); /*所要输出的复数实部虚部都不为零时的情况*/}}/*按复数的形式输出复数*/void Printreal(Complex c){printf("该复数的实部是：%5.2f\n",c.real);}/*输出复数的实部*/void Printimage(Complex c){printf("该复数的虚部是：%5.2f\n",c.image);}/*输出复数的虚部*/二、【详细设计】1、分别编写出对两个复数求和、求差、求积以及输出复数和复数的实部虚部的函数，通过在主程序中调用这些函数，来达到实验要求。

《数据结构》实验报告题目：复数的四则运算专业：计算1191学号： **********姓名：***2012-2013学年第一学期一实验内容实验1 抽象数据类型复数的实现二实验目的1.设计一个可以进行复数运算的演示程序三需求分析实现下列六种基本预算：1）由输入的实部虚部生成一个复数；2）两个复数求和；3）两个复数求差；4）两个复数求积；5）从已知复数中分离出实部；6）从已知复数中分离出虚部；四详细设计源程序：# include"stdio.h"# include"stdlib.h"struct complex{float real;float imaginary;};void InitComplex(complex &c,float r1,float r2){c.real=r1;c.imaginary=r2;}void AddComplex(complex &c,complex c1,complex c2){c.real=c1.real+c2.real;c.imaginary=c1.imaginary+c2.imaginary;}void SubComplex(complex &c,complex c1,complex c2){c.real=c1.real-c2.real;c.imaginary=c1.imaginary-c2.imaginary;}void MulComplex(complex &c,complex c1,complex c2){c.real=(c1.real*c2.real)-(c1.imaginary*c2.imaginary);c.imaginary=(c1.real*c2.imaginary)+(c2.real*c1.imaginary);}void RealComplex(complex c,float &r){r=c.real;}void ImaComplex(complex c,float &r){r=c.imaginary;}void main(){complex c,c1,c2;float r,r1,r2,r11,r12,r21,r22;int node;printf("请?输º?入¨?序¨°号?:\n");printf("1:构1造¨¬复¡ä数ºy;2:复¡ä数ºy求¨®和¨ª;3:复¡ä数ºy求¨®差?\n");printf("4:复¡ä数ºy求¨®积y;5:返¤¦Ì回?实º¦Ì部?;6:返¤¦Ì回?虚¨¦部?\n");scanf("%d",&node);while(node!=0){switch(node){case1: printf("请?输º?入¨?复¡ä数ºy：êo实º¦Ì部?，ê?虚¨¦部?\n"); scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);printf("构1造¨¬复¡ä数ºy:c=%f+i%f\n",c.real,c.imaginary);break;case2: printf("请?输º?入¨?复¡ä数ºyc1的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);AddComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case3: printf("请?输º?入¨?复¡ä数ºyc1的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);SubComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case4: printf("请?输º?入¨?复¡ä数ºyc1的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);MulComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case5: printf("请?输º?入¨?复¡ä数ºyc的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n"); scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);RealComplex(c,r);printf("结¨¢果?为a:%f\n",r);break;case 6: printf("请?输º?入¨?复¡ä数ºyc的Ì?：êo实º¦Ì部?，ê?虚¨¦部?\n");scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);ImaComplex(c,r);printf("结¨¢果?为a:%f\n",r);break;default:printf("结¨¢束º?");}}}加法程序展示：减法程序展示：求积程序展示：分离出实部；分离出虚部：步骤五:实验总结1.通过本次实验，基本掌握抽象数据类型的定义方法及要求；2.基本掌握C语言程序设计的规范操作流程；3.编程过程中有些地方考虑不全面，程序不够健壮，；。

复数加减乘除的实验报告一、实验目的：了解类和对象的概念，利用类来解决问题，同时熟悉运算符重载的定义，并学会使用运算符重载。

二、实验内容及流程1、定义一个复数类Compex,公有成员为7个成员函数，构①造函数Compex(double=0.0,double=0.0)实现了对象的初始化，Compex operator+(const Compex&)const;Compex operator-(const Compex&)const;Compex operator*(const Compex&)const;Compex operator/(const Compex&)const;Compex &operator=(const Compex&);符号+-*/不用定义函数，就能够实现整形、浮点型、等一些预定义类型的加减乘除的运算，是因为在文件内部已将定义好这些函数对这些符号进行重载，对象是类的实例化，是新的数据类型，所以要定义函数对利用这些符号进行对象的加减乘除。

void print()const;是现实复数的函数，包括复数的实部和虚部是否为零，正负等情况②私有成员为两个数据包括实部real和虚部imaginary。

2、程序的设计流程图三、程序源代码#include"stdafx.h" #include<iostream>using namespace std;class Compex{public:Compex(double=0.0,double=0.0);Compex operator+(const Compex&)const;Compex operator-(const Compex&)const;Compex operator*(const Compex&)const;Compex operator/(const Compex&)const;Compex &operator=(const Compex&);void print()const;private:double real;double imaginary;};Compex::Compex(double r,double i){real=r;imaginary=i;}//析构函数void Compex::print()const{ if(real<0){ if(imaginary<0)cout<<" ("<<real<<")+("<<imaginary<<")i";else{if(imaginary==0)cout<<" "<<real;elsecout<<" ("<<real<<")+"<<imaginary<<"i"; }}else{if(real==0)if(imaginary==0)cout<<"没有此复数"<<endl;elsecout<<imaginary<<"i";elseif(imaginary<0)cout<<" "<<real<<"+("<<imaginary<<")i";elseif(imaginary==0)cout<<" "<<real;elsecout<<" "<<real<<"+"<<imaginary<<"i";}}//显示复数Compex Compex::operator+(const Compex&operand2)const {Compex sum;sum.real=real+operand2.real;sum.imaginary=imaginary+operand2.imaginary;return sum;}//＋运算符的重载Compex Compex::operator-(const Compex&operand2)const {Compex diff;diff.real=real-operand2.real;diff.imaginary=imaginary-operand2.imaginary;return diff;}//见运算符的重载Compex Compex::operator*(const Compex&operand2)const {Compex diff;diff.real=real*operand2.real-imaginary*operand2.imaginary; diff.imaginary=real*operand2.imaginary+operand2.real*imagin ary;return diff;}//乘运算符的重载Compex Compex::operator/(const Compex&operand2)const{Compex diff;diff.real=(real*operand2.real+imaginary*operand2.imaginary) /(operand2.real*operand2.real+operand2.imaginary*operand2.i maginary);diff.imaginary=(imaginary*operand2.real-real*operand2.imagi nary)/(operand2.real*operand2.real+operand2.imaginary*opera nd2.imaginary);return diff;}//除的重载Compex &Compex::operator=(const Compex&right){real=right.real;imaginary=right.imaginary;return *this;}int _tmain(int argc, _TCHAR* argv[]){ cout<<"1---进行复数的运算"<<endl;cout<<"2---退出程序"<<endl;int i;cin>>i;while(i){ fflush(stdin);if(i==1){double a[2]={0.0};double b[2]={0.0};cout<<"输入第一个复数的实部和虚部"<<endl;cin>>a[0];cin>>a[1];cout<<"输入第二个复数的实部和虚部"<<endl;cin>>b[0]>>b[1];Compex x,y(a[0],a[1]),z(b[0],b[1]);cout<<"\n复数y：";y.print();cout<<"\n复数z：";z.print();x=y+z;cout<<"\n\nx=y+z:\n";x.print();cout<<"=";y.print();cout<<" +";z.print();x=y-z;cout<<"\n\nx=y-z:\n"; x.print();cout<<"=";y.print();cout<<" -";z.print();cout<<'\n';x=y*z;cout<<"\n\nx=y*z:\n"; x.print();cout<<"=";y.print();cout<<" *";z.print();cout<<'\n';x=y/z;cout<<"\n\nx=y/z:\n"; x.print();cout<<"=";y.print();cout<<" /";z.print();cout<<'\n';cout<<"1---进行复数的运算"<<endl;cout<<"2---退出程序"<<endl;cin>>i;}elseif(i==2)return 0;else{cin.clear();cout<<"加减不清楚请重新输入"<<endl;cin>>i;}}}四、运行结果1、如果输入的为1，任意输入两个复数显示结果如下2、如果输入的为2，结果如下3、如果输入的为其他任意值或者为字符情况，结果显示如下五、实验总结1、通过编写复数类，更进一步加深了对类和对象的了解，类是对象的抽象数据类型，是对象的特性和操作，对象是类的实例化，是具体的。

两个复数运算实验报告一、实验目的1、理解运算符重载的概念和意义。

2、了解运算符重载的限制。

3、掌握一游原函数的方式重载运算符的方法。

4、用运算符重载的方式实现复数的加、减、乘、除运算。

二、功能实现：1、定义复数类程序中，在类complex中定义了5个特殊的成员函数（运算符重载函数）：operator+、operator-、operator*、operator/、operator=，这3个函数分别实现的复数的加、减、乘、除和赋值运算，他们都是运算符重载函数。

还定义了一个友元函数a，来实现对x、y运算值的改变。

class complex{public:complex(double a=0.0,double b=0.0);complex operator+(complex &);complex operator-(complex &);complex operator*(complex &);complex operator/(complex &);complex &operator=(complex &);void print();private:double real;double imaginary;};2、构造函数的实现复数的构造函数用默认参数的构造函数。

当不给函数赋初值的话函数默认为0。

算法实现如下：complex::complex(double m,double n){real=m;imaginary=n;}3、加法功能复数的加法为 (a+bi)+(c+di)=(a+c)+(b+d)i，算法实现如下：complex complex::operator +(complex &a){complex b;b.real=real+a.real;b.imaginary= imaginary+a.imaginary;return b;}4、减法功能实现复数的减法运算为(a+bi)-(c+di)=(a-c)+(b-d)i，算法实现如下：complex complex::operator -(complex &a){complex b;b.real=real-a.real;b.imaginary=imaginary-a.imaginary;return b;}5、乘法功能实现复数的乘法运算为(a+bi)(c+di)=(ac－bd)+(bc+ad)i，算法实现如下：complex complex::operator *(complex &a){complex b;b.real=real*a.real-imaginary*a.imaginary;b.imaginary=real*a.imaginary+imaginary*a.real;return b;}6、除法功能的实验复数的除法运算为:(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i，运算除法还应虑除数为零的情况，所以除法运算的算法如下：complex complex::operator /(complex &a){complex b;if(a.real*a.real-a.imaginary*a.imaginary==0){cout<<"这个复数不能进行除法。

实验报告课程数据结构实验名称抽象数据类型第页专业_数学与应用数学___ 班级___双师1班 ______ 实验日期： 2012 年 9 月 18 日报告退发 (订正、重做)一、实验目的了解抽象数据类型的定义、表示和实现方法，加强对抽象数据类型在算法中的运用。

二、实验内容实现抽象数据类型“复数”并编写程序实现复数的加法、减法、乘法，以及求复数的实部、虚部等基本操作。

三、实验环境Vc++6.0 实验室四、实验步骤程序如下：#include<stdio.h>#include<stdlib.h>typedef struct{float real;float imag;}fushu;void getfushu(fushu& f,float a,float b);void plusfushu(fushu& plu,fushu f1, fushu f2);void minusfushu(fushu& min,fushu f1, fushu f2);void multifushu(fushu& mul,fushu f1, fushu f2);void printfushu(fushu f);void getfushu(fushu& f,float a,float b){f.real=a;f.imag=b;}void plusfushu(fushu& plu,fushu f1,fushu f2){plu.real=f1.real+f2.real;plu.imag=f1.imag+f2.imag;}void minusfushu(fushu& min,fushu f1,fushu f2){min.real=f1.real-f2.real;min.imag=f1.imag-f2.imag;}void multifushu(fushu& mul,fushu f1,fushu f2) {mul.real=(f1.real*f2.real)-(f1.imag*f2.imag); mul.imag=(f1.real*f2.imag)+(f1.imag*f2.real); }void printfushu(fushu f){if (f.real!=0)printf("%lf",f.real);if (f.imag>0){printf("+");printf("%lfi",f.imag);}else if(f.imag<0){printf("%lfi",f.imag);}}void main(){float a,b,c,d;fushu f1,f2,plu,min,mul;printf("Ç밴ʵ²¿Ð鲿µÄ˳ÐòÒÀ´ÎÊäÈëÁ¼·ö·´Êý£¹"); scanf("%f%f%f%f",&a,&b,&c,&d);getfushu(f1,a,b);getfushu(f2,c,d);printf("\nÄúÊäÈëµÄµÚÒº·ö·´ÊýÊÇ:");printfushu(f1);printf("\nÄúÊäÈëµÄµÚ¶þ·ö·´ÊýÊÇ:");printfushu(f2);plusfushu(plu,f1,f2);printf("\nÏà»Ó¼á¸ûΪ:");printfushu(plu);minusfushu(min,f1,f2);printf("\nÏà»õ¼á¸ûΪ:");printfushu(min);multifushu(mul,f1,f2);printf("\nÏà³Ë¼á¸ûΪ:");printfushu(mul);printf("\n");}五、实验结果与讨论请按实部虚部的顺序依次输入两个复数：8,9,10,12您输入的第一个复数是:8.000000+9.000000i您输入的第二个复数是:10.000000+12.000000i相加结果为:18.000000+21.000000i相减结果为:-2.000000-3.000000i相乘结果为:-28.000000+186.000000iPress any key to continue六、总结（说明实验过程中遇到的问题及解决办法；新发现或个人的收获；未解决/需进一步研讨的问题或建议新实验方法等）1.刚开始不理解题目的目的，以为是编两个程序，后来问同学才知道。

数据结构实现简单的复数ADT 复数ADT(抽象数据类型, Abstruct Data Type)ADT Complex{数据对象：{ e1, e2 | e1, e2(-R, R是实数集 }数据关系 : { <e1, e2>| e1是复数的实部, e2是复数的虚部 }基本操作 :create(&C, x, y)操作结果：构造复数C. 其实部和虚部分别被赋予以参数x和y的值。

getReal(C)初始条件：复数C已存在。

操作结果：返回复数C的实部值。

getImag(C)初始条件：复数C已存在。

操作结果：返回复数C的虚部值。

add(C1, C2)初始条件：C1, C2是复数。

操作结果：返回两个复数C1, C2的和。

sub(C1, C2)初始条件：C1, C2是复数。

操作结果：返回两个复数C1, C2的差}ADT ComplexC语⾔实现和简单测试，指针传参版/*** 数据对象和数据关系的实现*/struct Complex{double real;double imag;//imaginary:想象的，虚构的};/*** 基本操作的实现*/Complex* create( Complex* C, double x, double y){C->real = x;C->imag = y;}double getReal(const Complex* C){return C->real;}double getImga(const Complex* C){return C->imag;}Complex* add(const Complex* C1, const Complex* C2){Complex* C = new Complex;C->real = C1->real + C2->real;C->imag = C1->imag + C2->imag;return C;}Complex* sub(const Complex* C1, const Complex* C2){Complex* C = new Complex;C->real = C1->real - C2->real;C->imag = C1->imag - C2->imag;return C;}int main(){Complex *C1 = new Complex;create(C1,12,1);Complex *C2 = new Complex;create(C2,3,5);Complex *C = add(C1,C2);cout<<getReal(C)<<endl;cout<<getImga(C)<<endl;return0;}c语⾔实现和简单测试，不使⽤指针传参/*** 数据对象和数据关系的实现*/struct Complex{double real;double imag;//imaginary:想象的，虚构的};/*** 基本操作的实现*/Complex create(double x, double y){Complex c;c.real = x;c.imag = y;return c;}double getReal(const Complex c){return c.real;}double getImag(const Complex c){return c.imag;}Complex add(Complex c1, Complex c2){Complex c;c.real = c1.real + c2.real;c.imag = c1.imag + c2.imag;return c;}int main() {Complex c1 = create(123,1);Complex c2 = create(131,2333);Complex c = add(c1, c2);cout<<c.real<<""<<c.imag<<endl;Complex c3{12,12};cout<<c3.real<<""<<c3.imag<<endl;return0;}测试为了⽅便，使⽤了C++的输出⽅式运⾏时需要额外增加包含头⽂件iostream的代码和使⽤std名称空间的代码#include<stdio.h>#include<iostream>using namespace std;。