数据结构与算法(复数表示)

数据结构与算法
这是知识点出处bilibili
1.数据结构研究
利用计算机解决问题步骤：具体对象抽象为数学模型（分析问题 提取操作对象 找出操作对象之间的关系 用数学语言描述）——设计算法——编程.调试.运行 （操作对象与操作对象之间的关系为数据结构）
例如
学生管理系统
操作对象：每位学生的信息（学号，姓名，性别，籍贯等）
操作算法：查询，插入，修改，删除等
操作对象之间的关系：线性关系（一对一）
数据结构：线性数据结构，线性表
地图导航——最短路径
操作对象：各地点及路的信息
计算机算法：设置信号灯，求出各个可同时通行的路的集合
对象之间的关系：非线性关系，网状结构
————————————————————————2.基本概念
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及他们之间的关系和操作的学科。
3.
数据：是能够被输入计算机且能被计算机处理的各种符号的集合
数据包括数字型的数据（整数，实物等）和非数值型的数据（文字，图像，图形，声音）。
数据元素：是数据的基本单位，在计算机程序中通常作为一个整体进行考虑进而处理。也被称为元素，记录，结点或是顶点。
数据元素可由若干个数据项组成。
数据项是构成数据元素的不可分割的最小单位。
数据，数据元素，数据项之间的关系：
数据>数据元素>数据项
数据对象：是性质相同的数据元素的集合，是数据的一个子集
例如：整数数据对象：N={0,±1，±2…}
数据元素与数据的关系是：集合的个体
数据对象与数据的关系是：集合的子集
4.
数据元素不是孤立存在的，它们之间存在某种关系，数据元素相互之间的关系称为结构。是指相互之间存在一种或多种特定关系的数据元素集合。或者说，数据结构是带结构的数据元素的集合。
数据结构包括三方面内容：
1.数据元素之间的逻辑关系，称为逻辑结构
2.数据元素及其关系在计算机内存中的表示（映像），称为数据的物理结构或是数据的存储结构。
3.数据的运算和实现，即对数据元素可以施加的操作以及这些操作在相应的存储结构上的实现。
逻辑结构：线性结构（线性表，栈，队列，串）
非线性结构（树—一对多的层次关系，图）
存储结构：顺序存储结构（数组）
链式存储结构（指针）
索引存储结构（手机中的通讯录，地址）
散列存储结构
5.
抽象数据类型（ADT）
如 ADT Circle{
数据对象：D={r,x,y|r,x,y为实数}
数据关系：R={< r,x,y>|r是半径，是圆心坐标}
基本操作：Circle(&C,r,x,y)
操作的结果：构造一个圆
double Area©
初始条件：圆已存在
操作结果：计算面积
double Circumference©
初始条件：圆已存在
操作结果：计算周长
}ADT Circle

ADT Complex{
D={r1,r2|r1,r2都是实数}
S={|r是实部，r2是虚部}
assign(&C,v1,v2)
初始条件：空的复数C已存在
操作的结果：构造复数C,r1,r2分别被赋以参数v1,v2的值
destroy(&C)
初始条件：复数C已存在
操作结果：复数C被销毁
}ADT Complex

Assign(&Z,v1,v2)
操作结果：构造复数Z，其实部与虚部，分别被赋以参数v1,v2的值
Destroy(&Z)
操作结果：复数Z被销毁
GetReal(Z,&realPart)
初始条件：复数已存在。操作结果：用realPart返回复数Z的实部值
GetImag(Z.&ImagPart)
初始条件：复数已存在。操作结果：用ImagPart返回复数z的虚部值
Add(z1,z2,&sum)
初始条件：z1,z2是复数。操作结果：sum返回俩个复数z1,z2的和
抽象数据类型举例

//计算z=[(8+6i)(4+3i)]/[(8+6i)+(4+3i)];
#include
typedef struct complex{
float realpart;
float imagpart;
}complex;
//complex是定义的一个结构体类型 带*：指针变量，是指向complex类型的指针 不带*：complex的普通变量
complex assign(double real,double imag);//构造赋值
complex add(complex B,complex C);
complex minus(complex B,complex C);
complex multiply(complex B,complex C);
complex divide(complex B,complex C);

complex assign(double real,double imag){
complex A;
A.realpart=real;
A.imagpart=imag;
return A;
}
complex add(complex B,complex C){
complex A;
A.realpart=B.realpart+C.realpart;
A.imagpart=B.imagpart+C.imagpart;
return A;
}
complex multiply(complex B,complex C){complex A;
A.realpart=B.realpart*C.realpart-B.imagpart*C.imagpart;
A.imagpart=B.imagpart*C.realpart+B.realpart*C.imagpart;
return A;
}
complex divide(complex B,complex C){complex A;
A.realpart=	(B.realpart*C.realpart+B.imagpart*C.imagpart)/(C.imagpart*C.imagpart+C.realpart*C.realpart);
A.imagpart=(B.imagpart*C.realpart-C.imagpart*B.realpart)/(C.imagpart*C.imagpart+C.realpart*C.realpart);
return A;
}
int  main(){
complex z1,z2,z3,z4,z;double realpart,imagpart;
 z1= assign(8.0,6.0);//构造复数z1
printf("1     %.2lf+%.2lfi\n",z1.realpart,z1.imagpart);
 z2=assign(4.0,3.0);//构造复数z2
 printf("2     %.2lf+%.2lfi\n",z2.realpart,z2.imagpart);
 z3=add(z1,z2);//俩个复数相加
 printf("3     %.2lf+%.2lfi\n",z3.realpart,z3.imagpart);
 z=multiply(z1,z2);//俩个复数相乘
  printf("4     %.2lf+%.2lfi\n",z.realpart,z.imagpart);
 z4=divide(z,z3);//俩个复数相除
  printf("5     %.2lf+%.2lfi\n",z4.realpart,z4.imagpart);
} // %.2lf+%.2lfi    .2表示小数点后俩位，lf表示double类型

此代码借鉴[なるnaruuuu](https://blog.csdn.net/nruuu/article/details/110452802?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161692193016780274117562%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161692193016780274117562&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-17-110452802.pc_search_positive&utm_term=C%E8%AF%AD%E8%A8%80%E5%A4%8D%E6%95%B0%E5%AE%9E%E7%8E%B0)
#include
typedef struct complex {
	float realpart;
	float imagpart;
}complex;
//complex是定义的一个结构体类型 带*：指针变量，是指向complex类型的指针 不带*：complex的普通变量
complex assign(complex &A, float real, float imag);//构造赋值
complex add(complex &A, complex B, complex C);
complex minus(complex &A, complex B, complex C);
complex multiply(complex &A, complex B, complex C);
complex divide(complex &A, complex B, complex C);

complex assign(complex &A, float real, float imag) {

	A.realpart = real;
	A.imagpart = imag;

}
complex add(complex &A, complex B, complex C) {

	A.realpart = B.realpart + C.realpart;
	A.imagpart = B.imagpart + C.imagpart;


}
complex multiply(complex &A, complex B, complex C) {

	A.realpart = B.realpart*C.realpart - B.imagpart*C.imagpart;
	A.imagpart = B.imagpart*C.realpart + B.realpart*C.imagpart;

}
complex divide(complex &A, complex B, complex C) {

	A.realpart = (B.realpart*C.realpart + B.imagpart*C.imagpart) / (C.imagpart*C.imagpart + C.realpart*C.realpart);
	A.imagpart = (B.imagpart*C.realpart - C.imagpart*B.realpart) / (C.imagpart*C.imagpart + C.realpart*C.realpart);

}
int  main() {
	complex z1, z2, z3, z4, z; float realpart, imagpart;
	//z=[(8+6i)(4+3i)]/[(8+6i)+(4+3i)];
	assign(z1, 8.0, 6.0);//构造复数z1
	printf("1     %.2f+%.2fi\n", z1.realpart, z1.imagpart);
	assign(z2, 4.0, 3.0);//构造复数z2
	printf("2     %.2f+%.2fi\n", z2.realpart, z2.imagpart);
	add(z3, z1, z2);//俩个复数相加
	printf("3     %.2f+%.2fi\n", z3.realpart, z3.imagpart);
	multiply(z, z1, z2);//俩个复数相乘
	printf("4     %.2f+%.2fi\n", z.realpart, z.imagpart);
	divide(z4, z, z3);//俩个复数相除
	printf("5     %.2f+%.2fi\n", z4.realpart, z4.imagpart);
	
}

#include
typedef struct complex {
	double realpart;
	double imagpart;
}complex;
//complex是定义的一个结构体类型 带*：指针变量，是指向complex类型的指针 不带*：complex的普通变量
complex assign(complex *A,double real, double imag);//构造赋值
complex add(complex *A,complex * B, complex *C);
complex minus(complex *A,complex *B, complex *C);
complex multiply(complex *A,complex* B, complex *C);
complex divide(complex *A,complex *B, complex *C);

complex assign(complex *A,double real, double imag) {
	
	A->realpart = real;
	A->imagpart = imag;
	printf("%.2lf+%.2lfi\n", A->realpart, A->imagpart);
	
}
complex add(complex *A,complex *B, complex *C) {
    
	A->realpart = B->realpart + C->realpart;
	A->imagpart = B->imagpart + C->imagpart;
	printf("%.2lf+%.2lfi\n",   A->realpart, A->imagpart);
	//->用来 指向结构体子数据的指针，用来取子数据 
}

用法借鉴[WTomster](https://blog.csdn.net/weixin_38885956/article/details/110295037?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161692193016780274117562%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161692193016780274117562&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-25-110295037.pc_search_positive&utm_term=C%E8%AF%AD%E8%A8%80%E5%A4%8D%E6%95%B0%E5%AE%9E%E7%8E%B0)

complex multiply(complex *A,complex *B, complex* C) {
	
	A->realpart = B->realpart*C->realpart - B->imagpart*C->imagpart;
	A->imagpart = B->imagpart*C->realpart + B->realpart*C->imagpart;
	printf("%.2lf+%.2lfi\n", A->realpart, A->imagpart);
}
complex divide(complex *A,complex *B, complex *C) {
	
	A->realpart = (B->realpart*C->realpart + B->imagpart*C->imagpart) / (C->imagpart*C->imagpart + C->realpart*C->realpart);
	A->imagpart = (B->imagpart*C->realpart - C->imagpart*B->realpart) / (C->imagpart*C->imagpart + C->realpart*C->realpart);
	printf("%.2lf+%.2lfi\n", A->realpart, A->imagpart);
}
int  main() {
complex	z1, z2,z3,z4, z; 
	//z=[(8+6i)(4+3i)]/[(8+6i)+(4+3i)];
assign(&z1,8.0, 6.0);//构造复数z1
assign(&z2,4.0, 3.0);//构造复数z2
add(&z3,&z1, &z2);//俩个复数相加

//printf("mian    %.2lf+%.2lfi\n",   z3.realpart, z3.imagpart);
//.前面的对象为结构类型的变量  ->左边应该是指向该结构体的指针 
multiply(&z,&z1, &z2);//俩个复数相乘
//printf("main    %.2lf+%.2lfi\n",   z.realpart, z.imagpart);
divide(&z4,&z, &z3);//俩个复数相除*/
//printf("main   %.2lf+%.2lfi\n",   z4.realpart, z4.imagpart);
return 0;
}