精华内容
下载资源
问答
  • #8/*随便写了一个,只求两个分数相加的*/#include#includeusingnamespacestd;structRational{intnumerator;intdenominator;};intGCD(inta,intb){intc;if(aswap(a,b);while(b){c=a%b;a=b;b=c;}returna;...

    #8

    /*随便写了一个,只求两个分数相加的*/

    #include 

    #include 

    using namespace std;

    struct Rational

    {

    int numerator;

    int denominator;

    };

    int GCD(int a ,int b)

    {

    int c;

    if (a 

    swap(a,b);

    while(b)

    {

    c = a%b;

    a = b;

    b = c;

    }

    return a;

    }

    int LCM(int a,int b)

    {

    return (a*b/GCD(a,b));

    }

    int main()

    {

    Rational a, b;

    int n,i;

    char str[100];

    printf("Input two rational one by one %cSample : 1/2 1/3%c : \n",char(91),char(93));

    for (int k = 0; k 

    {

    gets(str);

    int temp = 0;

    int len = strlen(str);

    for (i = 0; str[i] != '/' ; i++)

    temp = temp * 10 + str[i] - '0';

    if (k == 0)

    a.numerator = temp;

    else b.numerator = temp;

    temp = 0;

    for (i++; i 

    temp = temp * 10 + str[i] - '0';

    if (k == 0)

    a.denominator = temp;

    else b.denominator = temp;

    }

    int c = LCM(a.denominator , b.denominator);

    n = c/a.denominator*a.numerator + c/b.denominator*b.numerator;

    if (n%c == 0)

    printf("%d/%d + %d/%d = %d\n",a.numerator,a.denominator,b.numerator,b.denominator,n/c);

    else

    {

    int temp = GCD(n,c);

    printf("%d/%d + %d/%d = %d/%d\n",a.numerator,a.denominator,b.numerator,b.denominator,n/temp,c/temp);

    }

    return 0;

    }

    展开全文
  • 满意答案jiduyumenzhe推荐于 2017.11.24采纳率:41%等级:12已帮助:10463人有理数即分数,分数的数据类型是很简单的。另外,求有理数的分子,分母的问题,因为给的有理数只能是有限小数,所以根本没有疑问。但是...

    满意答案

    00e27ab806e4881f8254fe7ae8741834.png

    jiduyumenzhe

    推荐于 2017.11.24

    00e27ab806e4881f8254fe7ae8741834.png

    采纳率:41%    等级:12

    已帮助:10463人

    有理数即分数,

    分数的数据类型是很简单的。

    另外,求有理数的分子,分母的问题,因为给的有理数只能是有限小数,所以根本没有疑问。

    但是如果改成:

    求分子分母之和最小的,在一定误差范围内的分数,这个问题才有价值

    比如:

    0.3333333,如果误差为1e-4

    那么1/3明显要比333333/10000000

    下面给出一个实现(C++):

    struct RatNum

    {

    int a,b;

    static int GCD(int a,int b)

    {

    if(a<0)a=-a;

    if(b<0)b=-b;

    if(a==0)return b;

    if(b==0)return a;

    if(a

    {

    int c=a;

    a=b;

    b=c;

    }

    unsigned int c;

    while(c= a % b)

    {

    a = b ;

    b = c;

    }

    return b;

    }

    explicit RatNum(int aa=0,int bb=1)

    :a(aa),b(bb)

    {

    }

    explicit RatNum(double num,double esp=0.00000001)

    {

    if(esp<0)esp=-esp;

    for(b=1;;b++)

    {

    a=b*num+.5;

    double k=a-b*num;

    if(k<0)k=-k;

    if(k

    }

    }

    void norm()//约分

    {

    int c=GCD(a,b);

    a/=c;

    b/=c;

    if(b<0)

    {

    a=-a;

    b=-b;

    }

    }

    RatNum operator/(const RatNum& f)const

    {

    RatNum d=*this;

    d.a*=f.b;

    d.b*=f.a;

    return d;

    }

    RatNum operator-()const

    {

    RatNum ret=*this;

    ret.a=-ret.a;

    return ret;

    }

    void operator*=(const RatNum& f)

    {

    a*=f.a;

    b*=f.b;

    norm();

    }

    RatNum operator*(const RatNum& f)const

    {

    RatNum d=*this;

    d*=f;

    return d;

    }

    RatNum operator*(int q)const

    {

    RatNum d=*this;

    d.a*=q;

    return d;

    }

    void operator-=(const RatNum& f)

    {

    int bb=b;

    a*=f.b;

    b*=f.b;

    a-=f.a*bb;

    }

    void operator+=(const RatNum& f)

    {

    int bb=b;

    a*=f.b;

    b*=f.b;

    a+=f.a*bb;

    }

    void positive()

    {

    if (a<0)a=-a;

    }

    bool operator==(int n)

    {

    return a==n*b;

    }

    void operator=(int q)

    {

    a=q;

    b=1;

    }

    };

    40分享举报

    展开全文
  • 有理数抽象数据类型

    2014-06-05 23:20:30
    通过构造有理数抽象数据类型,完成有理分数加减乘除和求导操作。
  • 实现两个有理数相加、相减、相乘以及求分子或求分母的运算。
  • 抽象数据类型复数complex:ADT complex{数据对象:D={e1,e2|e1,e2∈R}数据关系:R1={}基本操作:Initcomplex(&T,v1,v2)操作结果:构造了复数T,元素e1,e2分别被赋以参数v1,v2的值.Destroycomplex(&T)初始...

    满意答案

    02ae427d08e371d7e90d5b995e828d6d.png

    hweiwei420

    2015.10.10

    02ae427d08e371d7e90d5b995e828d6d.png

    采纳率:50%    等级:13

    已帮助:14203人

    a.

    抽象数据类型复数complex:

    ADT complex{

    数据对象:D={e1,e2|e1,e2∈R}

    数据关系:R1={}

    基本操作:

    Initcomplex(&T,v1,v2)

    操作结果:构造了复数T,元素e1,e2分别被赋以参数v1,v2的值.

    Destroycomplex(&T)

    初始条件:复数T已存在.

    操作结果:复数T被销毁.

    Get(T,i,&e)

    初始条件:复数T已存在,1≤i≤2.

    操作结果:用e返回T的实部或虚部的值。

    Isascending(T)

    初始条件:复数T已存在。

    操作结果:两部分按升序排列,则返回1,否则返回0.

    Isdescending(T)

    初始条件:复数T已存在。

    操作结果:两部分按降序排列,则返回1,否则返回0.

    Put(&T,I,e)

    初始条件:复数T已存在, 1≤i≤2.

    操作结果:改变T实部或虚部的值为e.

    Max(T,&e)

    初始条件:复数T已存在。

    操作结果:用e返回实部,虚部中较大的值。

    Min(T,&e)

    初始条件:复数T已存在

    操作结果:用e返回实部,虚部中较小的值。

    }ADT complex

    b. 抽象数据类型有理数:

    ADT rational{

    数据对象:D={a,b|a,b为整数,且b不为0}

    数据关系:R={}

    基本操作:

    Initrational(&T,v1,v2)

    操作结果:构造有理数T,元素啊,a,b分别被赋以参数v1,v2的值。

    Destroyrational(&T)

    初始条件:有理数T已存在。

    操作结果:有理数T被销毁。

    Get(T,i,&e)

    初始条件:有理数T已存在,1≤i≤2.

    操作结果:用e返回T的分子或分母的值。

    Put(&T,i,e)

    初始条件:有理数T已存在,1≤i≤2.

    操作结果:改变T的分子或分母的值为e.

    Isascending(T)

    初始条件:复数T已存在。

    操作结果:两部分按升序排列,则返回1,否则返回0.

    Isdescending(T)

    初始条件:复数T已存在。

    操作结果:两部分按降序排列,则返回1,否则返回0.

    Max(T,&e)

    初始条件:有理数T已存在。

    操作结果:用e返回分子,母中较大一个的值。

    Min(T,&e)

    初始条件:有理数T已存在。

    操作结果:用e返回分子,分母中较小的一个。

    }ADT rational

    00分享举报

    展开全文
  • 关于抽象数据类型--有理数实现有理数的加减乘除运算
  • 复数、有理数C++实现
    #include <iostream>
    using namespace std;
    
    class Complex {
        private:
        double real;
        double imag;
    
        public:
        Complex(double r = 0, double i = 0);
        double get_real(void);
        double get_imag(void);
        void set_real(double r);
        void set_imag(double i);
        void print(void);
        friend Complex operator+(Complex &c1, Complex &c2);
        friend Complex operator-(Complex &c1, Complex &c2);
        friend Complex operator*(Complex &c1, Complex &c2);
        friend Complex operator/(Complex &c1, Complex &c2);
        friend bool operator==(Complex &c1, Complex &c2);
    };
    
    Complex::Complex(double r, double i) {
        real = r;
        imag = i;
    }
    
    double Complex::get_real(void) {
        return real;
    }
    
    double Complex::get_imag(void) {
        return imag;
    }
    
    void Complex::set_real(double r) {
        real = r;
    }
    
    void Complex::set_imag(double i) {
        imag = i;
    }
    
    void Complex::print(void) {
        cout << real;
    
        if (imag > 0) {
            cout << "+";
        }
    
        if (imag != 0) {
            cout << imag << 'i' << endl;
        }
    }
    
    Complex operator+(Complex &c1, Complex &c2) {
        return Complex(c1.real + c2.real, c1.imag + c2.imag);
    }
    
    Complex operator-(Complex &c1, Complex &c2) {
        return Complex(c1.real - c2.real, c1.imag - c2.imag);
    }
    
    Complex operator*(Complex &c1, Complex &c2) {
        return Complex(c1.real * c2.real - c1.imag * c2.imag,
                        c1.real * c2.imag + c1.imag * c2.real); 
    }
    
    Complex operator/(Complex &c1, Complex &c2) {
        double temp = 1 / (c2.real * c2.real + c2.imag * c2.imag);
    
        return Complex((c1.real * c2.real + c1.imag * c2.imag) * temp,
                        (c1.imag * c2.real - c1.real * c2.imag) * temp);
    }
    
    bool operator==(Complex &c1, Complex &c2) {
        return (0 == c1.real - c2.real) && (0 == c1.imag - c2.imag);
    }
    
    int main(void) {
        Complex c1(2.3, 4.7), c2(-23.3, 99.2323);
    
        cout << "c1 + c2 = " ; (c1 + c2).print();
        cout << "c1 - c2 = " ; (c1 - c2).print();
        cout << "c1 * c2 = " ; (c1 * c2).print();
        cout << "c1 / c2 = " ; (c1 / c2).print();
        c1 == c2 ? (cout << "c1 == c2" ) : (cout << "c1 != c2") << endl;
    
        return 0;
    }

    这里写图片描述

    #include <iostream>
    using namespace std;
    #include <utility>
    
    class Rational {
        private:
        pair<int, int> fraction;
        int gcd(int x, int y) {
        if (0 == x % y) {
            return y;
        }
    
        return gcd(y, x % y);
    }
    
        public:
        Rational(int numerator, int denominator);
        pair<int, int> get_rational(void);
        void set_numerator(int numerator);
        void set_denominator(int denominator);
        void print(void);
        friend Rational operator+(Rational &r1, Rational &r2);
        friend Rational operator-(Rational &r1, Rational &r2);
        friend Rational operator*(Rational &r1, Rational &r2);
        friend Rational operator/(Rational &r1, Rational &r2);
        friend bool operator==(Rational &r1, Rational &r2);
    };
    
    Rational::Rational(int numerator, int denominator) {
        if (0 != denominator) {
            fraction = pair<int, int>(numerator, denominator);
        } else {
            fraction = pair<int, int>(1, 1);
        }
    }
    
    pair<int, int> Rational::get_rational(void) {
        return fraction;
    }
    
    void Rational::set_numerator(int numerator) {
        fraction.first = numerator;
    }
    
    void Rational::set_denominator(int denominator) {
        if (0 != denominator) {
            fraction.second = denominator;
        }
    }
    
    void Rational::print(void) {
        if (0 == 1- fraction.second) {
            cout << fraction.first << endl;
            return;
        }
    
        if (0 == fraction.first) {
            cout << '0' << endl;
            return;
        }
    
        // 将分数最简化
        int _gcd = gcd(fraction.first, fraction.second);
        int a = fraction.first / _gcd;
        int b = fraction.second / _gcd;
    
        if ((a ^ b) < 0) {
            a < 0 ? (cout << a << " / " << b << endl) 
                    : (cout << -a << " / " << -b << endl) ;
            return;
        } else {
            a > 0 ? (cout << a << " / " << b << endl) 
                    : (cout << -a << " / " << -b << endl);
        }
    }
    
    Rational operator+(Rational &r1, Rational &r2) {
        return Rational(r1.fraction.first * r2.fraction.second + 
                        r1.fraction.second * r2.fraction.first,
                        r1.fraction.second * r2.fraction.second);
    }
    
    Rational operator-(Rational &r1, Rational &r2) {
        return Rational(r1.fraction.first * r2.fraction.second - 
                        r1.fraction.second * r2.fraction.first,
                        r1.fraction.second * r2.fraction.second);
    }
    
    Rational operator*(Rational &r1, Rational &r2) {
        return Rational(r1.fraction.first * r2.fraction.first,
                        r1.fraction.second * r2.fraction.second);
    }
    
    Rational operator/(Rational &r1, Rational &r2) {
        if (0 == r2.fraction.first) {
            return Rational(0, 0);
        }
    
        return Rational(r1.fraction.first * r2.fraction.second,
                        r1.fraction.second * r2.fraction.first);
    }
    
    bool operator==(Rational &r1, Rational &r2) {
        return (0 == r1.fraction.first * r2.fraction.second - 
                        r1.fraction.second * r2.fraction.first);
    }
    
    int main(void) {
        Rational r1 = Rational(98, 63);
        Rational r2 = Rational(-7, 53);
    
        cout << "r1 = " ; r1.print();
        cout << "r2 = " ; r2.print();
        if (r1 == r2) { 
            cout << "r1 == r2" << endl;
        } else {
            cout << "r1 != r2" << endl;
        }
        cout << "r1 + r2 = " ; (r1 + r2).print();
        cout << "r1 - r2 = " ; (r1 - r2).print();
        cout << "r1 * r2 = " ; (r1 * r2).print();
        cout << "r1 / r2 = " ; (r1 / r2).print();
    
        return 0;
    }

    这里写图片描述

    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include using namespace std;class Complex{private:int numerator;int denominator;public:Complex(int n1 = 0,int n2 = 1):numerator(n1),denominator(n2){}int ...
  • 1. 线性表的抽象数据类型定义为:  ADT LinkList{ 数据对象:D={ | IntSet,i=1,2,…,n,n 0} 数据关系:R1={, >| , D, ,i=2,…,n} 基本操作: InitList(*L) 操作结果:构造一个空的...
  •  数据对象:D={r,i | r,i为实数}  数据关系:S={<r,i>}  基本操作:  InitComplex(&C,re,im)  操作结果:构造一个复数C,实部为re,虚部为im。  DestoryComplex(&C)  初始条件:复数C...
  • 满意答案mkblue2014.06.15采纳率:48%等级:9已帮助:313人有理数即分数,分数的数据类型是很简单的。另外,求有理数的分子,分母的问题,因为给的有理数只能是有限小数,所以根本没有疑问。但是如果改成:求分子...
  • 抽象数据类型有理数四则运算。使用C语言编写
  • 优质解答有理数即分数,分数的数据类型是很简单的.另外,求有理数的分子,分母的问题,因为给的有理数只能是有限小数,所以根本没有疑问.但是如果改成:求分子分母之和最小的,在一定误差范围内的分数,这个问题才有价值...
  • C语言实现有理数数据类型有理数库)系列文章目录前言一、pandas是什么?二、使用步骤1.引入库2.读入数据总结学习目标:学习内容:学习时间:学习产出:项目场景:问题描述:原因分析:解决方案: 前言 提示:...
  • 什么是抽象数据类型

    千次阅读 2021-04-29 23:15:13
    抽象数据类型(Abstract Data Type,ADT)是计算机领域中被广泛接受的一种思想和方法,也是一种用于设计实现程序模块的有效技术。ADT的基本思想是抽象,或者说是数据抽象(与函数定义实现的计算抽象或过程抽象对应...
  • 有理数类.cpp

    2018-05-17 17:11:10
    定义并实现一个有理数类,包含以下功能: 1.构造函数 2.一个优化函数,它的作用是使有理数约去公分母,即使保存的有理数分子和分母之间没有公约数(除去1以外) 3.一个将有理数转换为实数的函数 4.实现两个有理数的...
  • 名人名言强调基础的重要性的句子不胜枚举,数据结构与算法作为计算机专业的必学科目,其重要性不言而喻。 在以往的教学体系中,数据结构与算法通常结合C语言进行教学,而近年来Python的兴起,已经引起了教学上的变化...
  • 博客作业01-抽象数据类型 1.作业内容(1分) 用ADT的抽象数据模型描述你的有理数数据类型。 ADT Rational { 数据对象:D={ | e1,e2∈I (I为整数集合) } 数据关系:R={ e1是有理数的分子,e2是有理数的分母,且e2>...
  • 学校认识管理系统中的类六、部分课后编程练习一、抽象数据类型抽象数据类型(ADT)是计算机领域的一种思想和方法,是一种用于设计实现程序模块的有效技术。模块通过接口来提供功能所需的信息,并不涉及具体实现细节...
  • 有理数抽象数据类型

    千次阅读 2010-11-22 18:44:00
    有理数作为一个抽象数据类型 有理数 (数字在形式a/b可以被写的a和b整数,并且b不零)在计算机不能当地代表。 合理的ADT能被定义如所示下面。 建筑: 使用二个整数, a和b创造一个有理数ADT的事例, ...
  • 抽象数据类型和Python类的基础

    千次阅读 2018-06-12 12:34:03
    从使用者的角度:抽象数据类型就是程序实现的一个功能部件,这个部件在头部定义了它的接口。不要求你知道它的内部细节。1.1.1 抽象数据类型的分类在每种编程语言中都有其内置的数据类型,比如①python中就有bool,int...
  • 01-抽象数据类型

    2018-03-08 21:48:00
    试仿照三元组或复数的抽象数据类型写出有理数抽象数据类型的描述 (有理数是其分子、分母均为整数且分母不为零的分数)。 有理数基本运算如下所示: 1.构造有理数T,元素e1,e2分别被赋以分子、分母值 2.销毁...
  • 第2章 抽象数据类型和Python类2.1 抽象数据类型抽象数据类型(Abstract Data Type,ADT)是计算机领域中被广泛接受的一种思想和方法,也是一种用于设计实现程序模块的有效技术。ADT的基本思想是抽象,或者说是数据...
  • 试仿照三元组或复数的抽象数据类型写出有理数抽象数据类型的描述 (有理数是其分子、分母均为整数且分母不为零的分数)。 有理数基本运算如下所示: 1.构造有理数T,元素e1,e2分别被赋以分子、分母值 2.销毁有理数T ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,384
精华内容 553
关键字:

设计实现抽象数据类型“有理数”