精华内容
下载资源
问答
  • 数据结构实验报告:复数实现和... 通过对复数抽象数据类型ADT实现,熟悉C语言语法及程序设计。为以后章节的学习打下基础。 实验环境:(包括软件平台和硬件平台) 编程软件:Visual Studio 2017 操作系统:windows 10
  • 复数ADT及其实现 运行程序,输入下列运行程序,输入下列两个复数的实部与虚部,记录两个复数相加,相减,相乘的结果。两个复数的实部与虚部,记录两个复数相加,相减,相乘的结果。 思路:结构体 #include<...

    复数ADT及其实现

    运行程序,输入下列运行程序,输入下列两个复数的实部与虚部,记录两个复数相加,相减,相乘的结果。两个复数的实部与虚部,记录两个复数相加,相减,相乘的结果。

    思路:结构体

    #include<iostream>
    #include<bits/stdc++.h>
    using namespace std; 
    struct comp{//建立结构体 
    	float x;
    	float y;
    }; 
    comp a,b,cnt_add,cnt_sub,cnt_chengji;//全局变量 
    int z;
    void creat(comp* c);//创建复数 
    void outputc(comp a);//输出复数 
    comp add(comp k,comp h);//复数相加 
    comp sub(comp k,comp h);//复数相减 
    comp chengji(comp k,comp h);//复数相乘
    
    int main(){//主函数 
    	creat(&a); outputc(a); 
    	creat(&b); outputc(b);
    	cnt_add=add(a,b);	outputc(cnt_add);
    	cnt_sub=sub(a,b);	outputc(cnt_sub);
    	cnt_chengji=chengji(a,b);	outputc(cnt_chengji);
    	return 0;
    } 
    
    
    void creat(comp* c){
    	float c1,c2;
    	cout << "输入实部 real=? "; cin >> c1;
    	cout << "输入虚部 xvpu=? "; cin >> c2;
    	(*c).x=c1;c->y=c2;
    } 
    
    void outputc(comp a){
    	if(a.y<0) printf("\n  %f%fi \n\n",a.x,a.y);
    	else printf("\n  %f+%fi \n\n",a.x,a.y);
    }
    
    comp add(comp k,comp h){
    	comp l;
    	l.x=k.x+h.x;
    	l.y=k.y+h.y;
    	return l;
    }
    
    comp sub(comp k,comp h){
    	comp l;
    	l.x=k.x-h.x;
    	l.y=k.y-h.y;
    	return l;
    } 
    
    comp chengji(comp k,comp h){
    	comp l;
    	l.x=k.x*h.x;
    	l.y=k.y*h.y;
    	return l;
    }
    
    
    展开全文
  • 数据结构复数ADT及其实现实验报告
  • 用C语言实现复数ADT的实例

    千次阅读 2020-04-14 15:12:59
    用C语言实现复数ADT的实例 ADT包括定义和实现两个方面,其中定义是独立于现实的。定义仅给出一个ADT的逻辑特性,不必考虑在计算中实现。 用C语言实现ADT 用C语言实现ADT时,主要包括一下两个方面。 通过结构体将...

    用C语言实现复数ADT的实例

    ADT包括定义和实现两个方面,其中定义是独立于现实的。定义仅给出一个ADT的逻辑特性,不必考虑在计算中实现。

    用C语言实现ADT

    用C语言实现ADT时,主要包括一下两个方面。

    1. 通过结构体将intfloat 等基本数据类型组合到一起,构成一个结构体类型,再用typedef为该类型或该类型指针重新起一个名字,以增强程序的抽象性、简洁性和可读性。即采用C语言中typedef自定义类型来实现。

    2. 用C语言的子函数实现各个操作。

      typedef可以用来建立已定义好的数据类型的别名。为建立便于记忆和使用的类型名,也为了省略结构标记,C程序员经常使用typedef来定义结构体结构。如typedef struct card Card;建立用户自定义的数据类型和新类型名为Card,他是类型~ 的别名,就可以利用Card类型名来替代struct card类型名。

    代码部分

    注意

    在敲代码的时候注意create()不要前面使用create()后面使用creat(),在用Dev C++

    编译的时候不会报错,但是运行的时候会报错。

    源码

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct{
    	float realpart;
    	float imagpart;
    } Complex;
    
    /* 函数原型说明部分。注意函数头后面有分号 */
    Complex create(float x, float y);
    Complex add( Complex z1, Complex z2 );
    
    /*函数定义部分。注意函数头后面有分号 */
    Complex create(float x, float y)
    /* 利用x,y创建复数z,并将z返回 */
    {
    	Complex z;
    	z.realpart = x;
    	z.imagpart = y;
    	return(z); 
    		
    }
    
    Complex add( Complex z1, Complex z2)
    /* 求复数z1、z2的和sum,并将sum返回 */
    {
    	Complex sum;
    	sum.realpart = z1.realpart + z2.realpart;
    	sum.imagpart = z1.imagpart + z2.imagpart;
    	return(sum);
    }
    
    int main()
    {
    	float a,b;
    	Complex c1,c2,c3;
    	printf(" \n\n\n Input realpart and imagpart:");
    	scanf("%f %f",&a,&b);
    	c1 = create(a,b);
    	printf(" \n\n\n Input realpart and imagpart:");
    	scanf("%f %f",&a,&b);
    	c2 = create(a,b);
    	c3 = add(c1,c2);
    	printf("\n\n  c1 == %f + %f i",c1.realpart,c1.imagpart);
    	printf("\n\n  c2 == %f + %f i",c2.realpart,c2.imagpart);
    	printf("\n\n  c3 == c1 + c2 = %f + %f i",c3.realpart,c3.imagpart);
    	return 0;
    }
    
    展开全文
  • C/C++实现复数ADT相关功能

    千次阅读 多人点赞 2020-05-22 20:26:19
    实现复数ADT,基本操作有创建复数、初始化、获取实部、获取虚部、加法、减法、乘法、打印复数等操作。 #pragma warning(disable : 4996) #include<iostream> #include<cstdio> #include<cmath>...

    C/C++实现复数相关运算

    C/C++实现复数相关运算,相关解释在代码中进行注释。

    原创亓官劼,请勿抄袭,转载请注明出处。


    实现了复数的ADT,基本操作有创建复数、初始化、获取实部、获取虚部、加法、减法、乘法、打印复数等操作。

    #pragma warning(disable : 4996)
    #include<iostream>
    #include<cstdio>
    #include<cmath>
    #include<cstdlib>
    #include<string>
    #include<algorithm>
    using namespace std;
    struct Complex{
        double Re;//实部
        double Im;//虚部
    };
    void CreatComplex(struct Complex input[],int Re,int Im,int n);//创建复数
    void InitialComplex(struct Complex input[],int n);//初始化;
    double GetRe(struct Complex input[],int n);//获得实部
    double GetIm(struct Complex input[], int n);//获得虚部
    Complex AddComplex(struct Complex input[], int n1, int n2);//加法
    Complex MinusComplex(struct Complex input[], int n1, int n2);//减法
    Complex MultiplicationComplex(struct Complex input[], int n1, int n2);//乘法
    void PrintComplex(struct Complex input[],int n);//打印
    int main(){
        //复数ADT
           int i;
           Complex a[100];
           int m = 0;
           printf("请输入需要进行的操作:\n");
           printf("1:初始化复数\n");
           printf("2:创建复数\n");
           printf("3:获得实部\n");
           printf("4:获得虚部\n");
           printf("5:两个复数的加法\n");
           printf("6:两个复数的减法\n");
           printf("7:两个复数的乘法\n");
           printf("8:打印已有所有复数\n");
           printf("9:退出程序\n");
           
           while (1)
           {
                  scanf("%d", &i);
                  switch (i)
                  {
                  case 1: {
                         for (int n = 0; n < 100; n++) {
                               InitialComplex(a,n);
                         }
                         printf("全部初始化完毕,请继续选择操作\n");
                  }
                         break;
                  case 2: {
                         double Re, Im;
                         printf("请输入创建复数的实部,虚部\n");
                         scanf("%lf%lf",&Re,&Im);
                         CreatComplex(a, Re, Im,m);
                         m++;
                         printf("创建完毕,请继续选择操作\n");
                  }
                         break;
                  case 3: {
                         int n;
                         printf("请输入获取第几个复数的实部:\n");
                         scanf("%d", &n);
                         printf("第%d个复数的实部为:%f", n, GetRe(a,n));
                  }
                         break;
                  case 4: {
                         int n;
                         printf("请输入获取第几个复数的虚部:\n");
                         scanf("%d", &n);
                         printf("第%d个复数的虚部为:%lf", n, GetIm(a,n));
                  }
                         break;
                  case 5: {
                         int n1, n2;
                         printf("请输入第几个复数和第几个复数相加:\n");
                         scanf("%d%d",&n1,&n2);
                         printf("相加后的结果为:%lf+%lf i", AddComplex(a,n1,n2).Re, AddComplex(a, n1, n2).Im);
                  }
                         break;
                  case 6: {
                         int n1, n2;
                         printf("请输入第几个复数和第几个复数相减:\n");
                         scanf("%d%d", &n1, &n2);
                         printf("相减后的结果为:%f+%f i", MinusComplex(a, n1, n2).Re, MinusComplex(a, n1, n2).Im);
                  }
                         break;
                  case 7: {
                         int n1, n2;
                         printf("请输入第几个复数和第几个复数相乘:\n");
                         scanf("%d%d", &n1, &n2);
                         printf("相乘后的结果为:%f+%f i", MultiplicationComplex(a, n1, n2).Re, MultiplicationComplex(a, n1, n2).Im);
                  }
                         break;
                  case 8: {
                         int n;
                         for (n = 0; n < m; n++) {
                               PrintComplex(a,n);
                         }
                  }
                         break;
                  case 9:return 0;
                  default:printf("请输入正确选项\n");
                         break;
                  }
           }
        return 0;
    }
    void CreatComplex(struct Complex input[], int Re, int Im,int n) {//创建复数
        input[n].Re=Re;
        input[n].Im=Im;
    }
    void InitialComplex(struct Complex input[],int n){//初始化;
        input[n].Re=0;
        input[n].Im=0;
    }
    double GetRe(struct Complex input[], int n) {//获得实部
        return input[n].Re;
    }
    double GetIm(struct Complex input[], int n) {//获得虚部
        return input[n].Im;
    }
    Complex AddComplex(struct Complex input[],int n1,int n2) {//加法
        Complex re;
        re.Re=input[n1].Re+input[n2].Re;
        re.Im=input[n1].Im+input[n2].Im;
        return re;
    }
    Complex MinusComplex(struct Complex input[], int n1, int n2){//减法
        Complex re;
        re.Re=input[n1].Re-input[n2].Re;
        re.Im=input[n1].Im-input[n2].Im;
        return re;
    }
    Complex MultiplicationComplex(struct Complex input[], int n1, int n2){//乘法
        Complex re;
        re.Re=((input[n1].Re*input[n2].Re)-(input[n1].Im*input[n2].Im));
        re.Im=((input[n1].Im*input[n2].Re)-(input[n1].Re*input[n2].Im));
        return re;
    }
    void PrintComplex(struct Complex input[],int n){//打印
        printf("%lf + %lf i\n",input[n].Re,input[n].Im);
    }
    

      大家好,我叫亓官劼(qí guān jié ),在CSDN中记录学习的点滴历程,时光荏苒,未来可期,加油~博客地址为:亓官劼的博客,B站昵称为:亓官劼,地址为亓官劼的B站

    本文原创为亓官劼,请大家支持原创,部分平台一直在盗取博主的文章!!!

    展开全文
  • 复数 一级ADT实现

    2019-08-12 19:28:29
    COMPLEX.h /* typedef struct { float RE; //实部 float IM; //虚部 }Complex; */ typedef struct complex * Complex; Complex COMPLEXinit(float, float); float Re(Complex);...Complex C...

    COMPLEX.h

    /*
    typedef struct
    {
        float RE; //实部
        float IM; //虚部
    }Complex;
    */
    typedef struct complex * Complex;
    
    Complex COMPLEXinit(float, float);
    float Re(Complex);
    float Im(Complex);
    Complex COMPLEXmult(Complex, Complex);

    COMPLEX.c

    #include "COMPLEX.h"
    
    struct complex
    {
        float RE; //实部
        float IM; //虚部
    };
    
    Complex COMPLEXinit(float RE, float IM)
    {
        /*
        Complex t;
        t.RE=RE;
        t.IM=IM;
        return t;
        */
        
        Complex t=malloc(sizeof *t);
        t->RE=RE;
        t->IM=IM;
        return t;
    }
    float Re(Complex z)
    {
        return z->RE;
    }
    float Im(Complex z)
    {
        return z->IM;
    }
    Complex COMPLEXmult(Complex a, Complex b)
    {
        /*
        Complex t;
        t.RE=a.RE*b.RE-a.IM*b.IM;
        t.IM=a.RE*b.IM+a.IM*b.RE;
        
        //a实部乘b实部-a虚部乘b虚部
        //a实部乘b虚部+a虚部乘b实部
        return t;*/
        
        return COMPLEXinit(Re(a)*Re(b)-Im(a)*Im(b),
                           Re(a)*Im(b)+Im(a)*Re(b));
    }

    main.c

    #include <stdio.h>
    #include <math.h>
    #include "COMPLEX.h"
    
    #define PI 3.141592625
    
    int main(void)
    {
        int N;
        printf("输入一个参数:");
        scanf("%d", &N);
        getchar();
        
        Complex t, x;
        printf("%dth complex roots of unity\n", N);
        for(int i=0; i<N; i++)
        {
            float r=2.0*PI*i/N;
            //1=e^(2n*pi*i)  ?
    
            
            t=COMPLEXinit(cos(r), sin(r));
            
            printf("%2d %6.3f %6.3f ", i, Re(t), Im(t));
            x=t;
            for(int j=0; j<N-1; j++)
                x=COMPLEXmult(t, x);
                
            printf("%6.3f %6.3f\n", Re(x), Im(x));
        }
        
        return 0;
    }

     

    展开全文
  • 数据结构作业一 抽象数据类型复数的定义表示及其实现 抽象数据类型复数的定义 ADT Complex{ 数据对象D={a,b|a,b?R,R为实数集} 数据关系S={,b>|a为复数实部b为复数虚部} 基本操你 Complex&z,a=0,b=0) 操作结果构造...
  • 什么是数据结构?

    千次阅读 2019-06-19 20:25:39
    数据的运算是数据结构的一个重要方面,讨论任一种数据结构时都离不开对该结构上的数据运算及其实现算法的讨论。 数据结构不同于数据类型,也不同于数据对象,它不仅要描述数据类型的数据对象,而且要描述数据对象各...
  • 数据结构作业一 抽象数据类型复数的定义表示及其实现 1. 抽象数据类型复数的定义 ADT Complex{ 数据对象 D={a,b|a,b R,R 为实数集 } 数据关系 S={,b>|a 为复数实部 b 为复数虚部 } 基本操你 Complex&z,a=0,b=0) 操作...
  • r1,r2分别被赋以参数v1,v2的值 destroy(&C) 初始条件:复数C已存在 操作结果:复数C被销毁 }ADT Complex Assign(&Z,v1,v2) 操作结果:构造复数Z,其实部与虚部,分别被赋以参数v1,v2的值 Destroy(&Z) 操作结果:复数...
  • 很多小伙伴在翻开数据结构的第一节课,听到的就是一个名为抽象数据类型...它通常是对数据的某种抽象,定义了数据的取值范围及其结构形式,以及对数据操作的集合。以复数为例,它的抽象数据类型如下: ADT c..
  • 首先进行说明,我们这里所描述到的的数据结构的内容在之后的代码实现过程中都是用C语言实现,本篇博客是后面...逻辑结构 :研究对象的特性及其相互之间的关系 存储结构:有效地组织计算机存贮 算法:有效地实现...
  • }ADT Circle ​ Circumference是周长的意思 抽象数据类型(ADT)定义举例:复数的定义 ADT Complex{ D={r1,r2|r1,r2都是实数} S={|r1是实部,r2是虚部} assgin(&C,v1,v2) 初始条件: 空的复数C已存在 操作结果: 构造...
  • 3. 抽象数据类型(Abstract Data Type,ADT):一个数据结构以及定义在该结构上的一组操作的总称。 1.4 算法及算法分析 算法的相关概念 1.算法(Algorithm):是对特定问题求解步骤的...
  • 这食材,就像是程序设计中的数据结构 Number、String、Array、List、Link、Map、Tree 、Graph 等,组合成不同的抽象数据类型(ADT),你也可以理解成数据结构、模型、类、对象等范畴。 然后,这些食材怎样早就这...
  • 数据结构 - 逻辑结构和存储结构

    万次阅读 2017-10-15 22:18:18
    ADT的定义仅是一组逻辑特性描述, 与其在计算机内的表示和实现无关。因此,不论ADT的内部结构如何变化,只要其数学特性不变,都不影响其外部使用。  ADT的形式化定义是三元组:ADT=(D,S,P)  其中:D是数据...
  • 数据结构

    2021-04-20 16:13:47
    2.1数据结构包括以下三个方面的内容 数据元素之间的逻辑关系,也成为逻辑结构 数据元素及其关系在计算机内存中的映像,也称为物理结构或者存储结构 数据的运算和实现,也就是操作数据元素或者操作相应存储结构的...
  • Android Stutio中使用java8的Lambda表达式

    千次阅读 2016-05-29 14:36:47
      目前Android开发工具已经从Eclipse 的ADT迁移到了Android Studio,但是Android Studio目前还没有直接支持Lambda,需要插件支持,当然,JDK版本也必须使用JDK 8 或者以上。按照下面步骤配置Gradle: (1). 引入...
  • 数据元素相互之间的关系称为结构,是指相互之间存在一种或多种特定关系的数据元素的集合 逻辑关系,逻辑结构 数据元素及其关系在计算机内存中的表示,物理结构,存储结构 数据的运算和实现,即对数据元素的操作以及在存储...
  • 实习一 复数ADT及其实现实习二 线性表实习三 栈和队列 实习四 串实习五 数组实习六 树与二叉树 实习七 图实习八 查找实习九 排序 全部C语言代码
  • 例:抽象数据类型的实现 //第一步:定义复数抽象类型 typedef struct{ float realpart; /*实部*/ float imagpart; /*虚部*/ } Complex; //第二步:函数声明 void assign(Complex *A, float real, float ...
  • 数据结构总结(全)

    2019-09-26 22:54:22
    逻辑结构是面向问题的,而物理结构就是面向计算机的,其基本的目标就是将数据及其逻辑关系存储到计算机的内存中。 1.1 物理结构 数据的逻辑结构在计算机存储空间的存放形式被称为数据的物理结构。 1.顺序...
  • 数据结构描述现实世界实体的数学模型(非数值计算)及其上的操作在计算机中的表示和实现 1.2 基本概念 一、数据与数据结构 数据: 所有能被输入到计算机中,且被计算机处理的符号的集 合计算机操作的对象的总称 是...
  • 抽象数据类型的实现 : 面向对象——类 面向过程——结构体 举个例子 : 【例1-5】复数数据类型的抽象描述 分析:定义——实部+i虚部 实部和虚部的取值范围——实数 复数的操作——+、-、×、% ADT复数的数据类型...
  • 构建抽象数据类型复数(e1+e2i) 通过上例可知,问题是要将复数加法描述出来,而抽象数据类型就是在这种形式化的描述下把数据的组成和如何操作的问题描述清楚,且没有涉及到具体的计算机具体实现的一些问题。...
  • … }ADT Circle 四、抽象数据类型的表示与实现 C语言实现抽象数据类型: 用已有数据类型定义描述它的存储结构 用函数定义描述它的操作 然后便可以在程序中使用 抽象数据类型可以通过固有的数据类型(如:整数、实型...
  • 数据结构概述

    千次阅读 2010-06-18 22:54:00
    整数、浮点数、复数、双精度数等  非数值型数据:字符、字符串,以及文字、图形、图像、语音等数据 2、数据结构 Data_Structure={ D , R }  数据结构有两个层次:抽象(逻辑结构)、实现...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 180
精华内容 72
关键字:

复数adt及其实现