精华内容
下载资源
问答
  • 整数

    2021-05-24 03:25:19
    【470】Keras API 参考说明2020-06-19 10:51:54参考:Keras API referencetf.keras.utils.to_categorical(y, num_classes=None, dtype="float32")将向量或整数转为二进制矩阵,类似one-hot编码numpy.random.randint...

    【470】Keras API 参考说明2020-06-19 10:51:54

    参考:Keras API reference

    tf.keras.utils.to_categorical(y, num_classes=None, dtype="float32")

    将向量或整数转为二进制矩阵,类似 one-hot 编码

    numpy.random.randint(low, high=None, size=None, dtype=int)

    返回指定范围内的随机整数,可以指定 shape/size

    运筹学整数规划matlab程序2020-06-18 23:41:39

    Gomory函数

    function [X,Z,AAA,BBB] = Gomory(A,B,C,D)

    % 割平面法的实现

    % X: 目标函数的最优解

    % Z: 目标函数的极小值

    % AAA:满足整数条件的最终表中的系数矩阵

    % BBB:满足整数条件的最终表中的常数列向量

    % A: 约束函数的系数矩阵,输入前需保证每个约束条件均为<或≤号

    %

    5.整数的机器数2020-06-18 15:58:06

    整数二进制充当统计模型2020-06-18 11:38:39

    最近项目中需要统计APP的最近几次的在线离线情况,因为有些商家的网络信号很差,需要根据最近的心跳在线离线情况做一些事情,例如统计商户APP最近10次的在线离线记录,如果最近10次有8次离线那就认识商家是网络比较差的商家,那么就去对这部分商家去做一些其他事情,那么怎么统计好呢?因为统

    1.2 变量和简单数据类型2020-06-18 10:08:44

    一、变量

    要理解新的编程概念,最佳的方式是尝试在程序中使用它们。

    二、字符串

    在Python中,用引号括起的都是字符串,其中的引号可以是单引号,也可以是双引号,这种灵活性让你能够在字符串中包含引号和撇号。

    2.1、使用方法修改字符串的的大小写

    title() 以首字母大写的方式显示每个单词

    leetcoede 8 字符串转换整数2020-06-17 21:52:38

    1 class At{

    2 string state="start";

    3 unordered_map>table={

    4 {"start",{"start","signed","in_number","end"}},

    5 {"in_number&quo

    二进制链表转整数2020-06-17 20:57:23

    由于链表中从高位到低位存放了数字的二进制表示,因此我们可以使用二进制转十进制的方法,在遍历一遍链表的同时得到数字的十进制值

    复杂度分析

    时间复杂度:O(N)O(N),其中 NN 是链表中的节点个数。

    空间复杂度:O(1)O(1)。

    第三天——整型和布尔值(一)2020-06-12 22:55:12

    整型和布尔值

    一. 整型(int)

    整型在Python中的关键字用int来表示; 整型在计算机中是用于计算和比较的

    在python3中所有的整数都是int类型. 但在python2中如果数据量比较大. 会使用long类型.

    在python3中不存在long类型 整数可以进行的操作:

    1.1 整数的加

    a = 10

    b = 20

    print(a + b)

    leetcode题解之最接近的三数之和2020-06-11 12:07:51

    给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数,使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

    示例:

    输入:nums = [-1,2,1,-4], target = 1

    输出:2

    解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

    比较字符串 P1012 拼数2020-06-09 11:41:18

    题目描述

    设有n个正整数(n≤20)(n≤20),将它们联接成一排,组成一个最大的多位整数。

    例如:n=3时,3个整数13,312,343联接成的最大整数为:34331213

    又如:n=4时,4个整数7,13,4,246联接成的最大整数为:7424613

    输入格式

    第一行,一个正整数nn。

    第二行,nn个正整数。

    输出格式

    一个正整数,表

    剑指offer面试题67. 把字符串转换成整数

    **

    # 面试题67. 把字符串转换成整数 写一个函数 StrToInt,实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。

    **

    首先,该函数会根据需要丢弃无用的开头空格字符,直到寻找到第一个非空格的字符为止。

    当我们寻找

    整数规划:

    clc,clear;

    c = [-40;-90];

    A = [9 7;7 20];

    b = [56;70];

    lb = zeros(2,1);

    [x,fval]= intlinprog(c,1:2,A,b,[],[],lb);

    fval = -fval

    x

    分支定界法或者割平面法求解纯或者混合整数线性规划问题;

    输出:

    当条件A,B之间不是且关系而是或的时候:

    固定成本问题

    python笔记-数字类型2020-06-07 18:56:50

    一、数字类型

    python中常用数值类型为整型, 浮点型和复数类型.

    整型

    浮点型

    复数类型

    复数包含实部和虚部,分别以一个浮点数表示。 要从一个复数 z 中提取这两个部分,可使用 z.real 和 z.imag

    此外,布尔值属于整数的子类型。 整数具有无限的精度。 浮点数通常使用 C 中的 double

    PHP floor() 函数2020-06-07 10:51:28

    实例

    向下舍入为最接近的整数:

    <?phpecho (floor(0.60) . "
    ");echo(floor(0.40) . "
    ");echo(floor(5) . "
    ");echo(floor(5.1) . "
    ");echo(floor(-5.1) . "
    ");echo(floor(-5.9));?&

    js数据类型2020-06-06 11:08:02

    ES5的时候,数据类型有6种,分别是:undefined、null、布尔值(Boolean)、字符串(String)、数值(Number)、对象(Object)。

    ES6 引入了一种新的原始数据类型Symbol,表示独一无二的值。它是 JavaScript 语言的第七种数据类型。so,ES6有七种数据类型,他们分类是:

    undefined、null、布尔值(Boolean)、字符串

    整数划分 dp+母函数2020-06-06 09:59:07

    dp:

    #include

    using namespace std;

    typedef unsigned int ui;

    typedef long long ll;

    typedef unsigned long long ull;

    #define pf printf

    #define mem(a,b) memset(a,b,sizeof(a))

    #define prime1 1e9+7

    #define prime2 1e9+9

    #define pi 3.14159265

    正则表达式2020-06-04 10:51:45

    常用正则表达式:

    匹配中文字符                 [\u4e00-\u9fa5]

    匹配双字节字符(包括汉字在内)   [^\x00-\xff]

    匹配空白行                   \n\s*\r

    匹配Email地址               [\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@

    C 常量2020-06-03 11:54:44

    常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。

    常量可以是任何的基本数据类型,比如整数常量、浮点常量、字符常量,或字符串字面值,也有枚举常量。

    常量就像是常规的变量,只不过常量的值在定义后不能进行修改。

    整数常量

    整数常量可以是十进制、八进制或十六进制

    题目链接

    原题解:

    只有一个模式的时候

    考虑现在有模式串$M$和文本串$S$,我们想知道是否有$S$的某个子串符合$M$。

    先对模式串和文本串进行转化,变成一个整数序列。对于某个字母,如果是在串中第一次出现,那么对应整数$0$;如果不是,则对应到其上一次出现的距离。

    比如串$ABBACAB$对应整数

    题目描述

    输入一个int型整数,按照从右向左的阅读顺序,返回一个不含重复数字的新的整数。

    输入描述:

    输入一个int型整数

    输出描述:

    按照从右向左的阅读顺序,返回一个不含重复数字的新的整数

    示例1

    输入

    9876673

    输出

    37689解题思路:此题比较简单,正常1分钟就可以算出来了,

    求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数?为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数(从1 到 n 中1出现的次

    题目:

    4的幂:给定一个整数 (32 位有符号整数),请编写一个函数来判断它是否是 4 的幂次方。

    示例 1:

    输入: 16

    输出: true

    示例 2:

    输入: 5

    输出: false

    进阶:

    你能不使用循环或者递归来完成本题吗?

    思路:

    思路较简单。

    程序:

    class Solution:

    def isPowerOfFour(self, num: int) ->

    剑指Offer之二进制中1的个数2020-05-26 09:54:02

    题目描述

    输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

    解法1:使用Integer.toBinanryString()返回int变量的二进制表示的字符串。

    【在Integer类中有静态方法toBinaryString(int i)方法,此方法返回int变量的二进制表示的字符串。同理,Integer类中也提供了toH

    强类型语言

    要求变量的使用要严格符合规定,所有变量都必需先定义后才能使用

    ps:String  (字符串)

    //数据类型   变量名  =值   ;

    java的数据类型主要分两大类

    基本类型

    引用类型

    基本类型主要是源自生活中所用到的数字和文字,而数字有包括整数和小数

    基本类型

    1整

    leetcode13. 罗马数字转整数2020-05-24 22:59:02

    罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。

    字符 数值

    I 1

    V 5

    X 10

    L 50

    C 100

    D 500

    M 1000

    例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X

    展开全文
  • 数据结构课内实验报告书一、实验题目:长整数四则运算二、实验目的:通过本次实验,熟练掌握链表的存储结构及其各种基本运算,体会链表操作的特点。三、实验要求:设计一个实现任意长的整数进行加法运算的演示程序。...

    数据结构

    课内实验报告书

    一、实验题目:长整数四则运算

    二、实验目的:

    通过本次实验,熟练掌握链表的存储结构及其各种基本运算,体会链表操作的特点。

    三、实验要求:

    设计一个实现任意长的整数进行加法运算的演示程序。

    要求:利用双向循环链表实现长整数的存储,每个结点含一个整形变量。任何整形变量的范围是 -(215 - 1)~(215 - 1)。输入和输出形式:按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开。

    四、测试数据:

    (1)0;0;应输出“0”。

    (2)-2345,6789;-7654,3211;应输出“-1,0000,0000”。

    (3)-9999,9999;1,0000,0000,0000;应输出“9999,0000,0001”。

    (4)1,0001,0001;-1,0001,0001;应输出“0”。

    (5)1,0001,0001;-1,0001,0000;应输出“1”。

    (6)-9999,9999,9999;-9999,9999,9999;

    应输出“1,9999,9999,9998”。

    (7)1,0000,9999,9999;1;

    应输出“1,0001,0000,0000”。

    五、设计与实现过程

    (1)存储结构的定义

    typedef struct int72 {

    int i[4];

    } INT72;

    INT72 a,b,c;

    typedef struct LinkNode

    {

    int data; //记录每个节点的整数(小于10000)

    LinkNode *next, *pre; //记录下一个节点的地址 *pre; //记录前一个节点的地址

    }linklist;

    (2)主要算法的描述

    void addtwo()

    //节点多的作为被加数,少的作为加数,实现整数绝对值大的加小的 //默认head0存的整数绝对值比head1大

    {

    int s=0,m1=head0->data,m2=head1->data;

    m1=(head0->pre->data/abs(head0->pre->data)); //head0的符号 m2=(head1->pre->data/abs(head1->pre->data)); //head1的符号 linklist *p=head0->pre->pre,*q=head1->pre->pre;

    result->data=head0->pre->data; //存结果的节点数和符号 while(q!=head1->pre)

    //head0存的整数绝对值比head1大,即head0的节点数大于或等于head1 {

    currptr=(linklist *)malloc(sizeof(linklist));

    currptr->data=(p->data)*m1+(q->data)*m2+s; //两整数相加

    if((m1*m2)>0) //如果符号相同

    {

    if(abs(currptr->data)-10000>=0) //相加后超过10000,则进位 {

    s=currptr->data/10000;

    currptr->data=abs(currptr->data)%10000;

    }

    else //abs(currptr->data)-10000

    {

    s=0;

    currptr->data=abs(currptr->data);

    }

    }

    else if(m1>0&&m2

    //符号不同,在此相当于实现两个正整数相减

    {

    s=0;

    if(currptr->data

    {

    currptr->data+=10000;

    s=-1;

    }

    }

    else if(m10)

    //符号不同,在此相当于实现负整数加上正整数

    {

    s=0;

    if(currptr->data>0) //大于0,

    {

    currptr->data=10000-currptr->data;

    s=1;

    }

    else currptr->data=abs(currptr->data);

    }

    currptr->next=result; //存入链表

    currptr->pre=result->pre;

    result->pre->next=currptr;

    result->pre=currptr;

    result=currptr;

    p=p->pre;

    q=q->pre;

    }

    //当head0节点数比head1长时,继续建链

    while(p!=head0->pre)

    {

    currptr=(linklist *)malloc(sizeof(linklist));

    currptr->data=p->data+s;

    s=currptr->data/10000;

    if((m1*m2)>0)

    {

    if(abs(currptr->data)-10000>=0)

    {

    s=currptr->data/10000;

    currptr->data=abs(currptr->data)%10000;

    }

    else {s=0;currptr->data=abs(currptr->data);}

    }

    else if(m1>0&&m2

    {

    s=0;

    if(currptr->data

    {

    currptr->data+=10000;

    s=-1;

    }

    }

    else if(m10)

    {

    s=0;

    if(currptr->data>0)

    {

    currptr->data=10000-currptr->data;

    s=1;

    }

    else currptr->data=abs(currptr->data);

    }

    currptr->data=abs(currptr->data)%10000;

    currptr->next=result;

    currptr->pre=result->pre;

    result->pre->next=currptr;

    result->pre=currptr;

    result=currptr;

    p=p->pre;

    }

    if(s!=0) //处理相加后,进位问题

    {

    currptr=(linklist *)malloc(sizeof(linklist));

    currptr->data=abs(s);

    currptr->next=result;

    currptr->pre=result->pre;

    result->pre->next=currptr;

    result->pre=currptr;

    result=currptr;

    result->pre->data=m1*(abs(result->pre->data)+1);

    }

    }

    六、技巧与体会

    在编写程序中尽量做到独立完成、对于自己想要完成的问题要主动编程完成、这样自己是一个很大的提升、也能学到很多的知识、熟练编程!以后要加强动手时间能力、多与同学交流算法精髓!

    展开全文
  • 整数四则运算_双向循环链表

    千次阅读 2017-04-07 11:51:27
    设计程序实现两个任意长整数的求和运算。 [ 基本要求 ] 利用双向循环链表实现长整数的存储, 每个结点含一个整型变量. 任何整型变量的范围是 -(215-1)~(215-1)。输入和输出形式: 按中国对于长整数的表 示习惯, 每...

    [ 问题描述 ]
    设计程序实现两个任意长整数的求和运算。
    [ 基本要求 ]
    利用双向循环链表实现长整数的存储, 每个结点含一个整型变量. 任何整型变量的范围是 -(215-1)~(215-1)。输入和输出形式: 按中国对于长整数的表
    示习惯, 每四位一组,组间用逗号隔开。
    [ 测试数据 ]
    (1) 0;0;应输出"0"。
    (2) -2345,6789;-7654,3211; 应输出"-1,0000,0000"。
    (3) -9999,9999; 1,0000,0000,0000; 应输出"9999,0000,0001"。
    (4) 1,0001,0001; -1,0001,0001; 应输出"0"。
    (5) 1,0001,0001; -1,0001,0000; 应输出"1"。
    [ 实现提示 ]
    (1) 每个结点可以存放的最大整数为 215-1 = 32767 才能保证两数相加不会溢出。但若这样存,即相当于按 32768 进制数存,在十进制数与32768 进制数间
    的转换十分不方便,故可以在每个结点中仅存十进制数的4 位,即不超过9999的非负整数, 整个链表被视为万进制。
    (2)可以利用头结点数据域的符号代表长整数的符号。 用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。两操作数的头指针存于指针数
    组中是简化程序结构的一种方法。不能给长整数位数规定上限。
    [ 选作内容 ]
    修改上述程序,使它在整型量范围是-(2n-1)~(2n-1) 的计算机上都能有效地运行。其中n 是由程序读入的参量。输入数据的分组方法可另行规定。

     

    big_num_op.h

     

    //
    // Created by Admin on 2017/3/31.
    //
    
    #ifndef BIG_NUM_BIG_NUM_OP_H
    #define BIG_NUM_BIG_NUM_OP_H
    
    #endif //BIG_NUM_BIG_NUM_OP_H
    
    #include <cstdio>
    #include <stdlib.h>
    #include <cstring>
    #include <cmath>
    #include <conio.h>
    #include <time.h>
    #include <algorithm>
    using namespace std;
    
    //定义结点
    typedef int ListData;
    typedef struct dnode{
        ListData data;
        struct dnode *prior,*next;
    }DblNode;
    typedef DblNode *DblList;
    
    //algorithm
    void InitList(DblList &first);
    void DestroyList(DblList &first);
    void ClearList(DblList &first);
    int ListLength(DblList first);
    void TravelList(DblList first);
    void PrtList(DblList first);
    void InputInteger(DblList &first,DblList &second);
    void newdnodeInset(DblList &p3,DblList &newdnode,DblList &result);
    void judgeAdd(int temp,int &k,DblList &newdnode);
    void addition(DblList &first,DblList &second,DblList &result);
    int cmpInteger(DblList first,DblList second);
    void subDnode(int len,DblList &first,DblList &second,DblList &result,int &i);
    void judgeSub(int temp,int &k,DblList &newdnode);
    void subtraction(DblList &first,DblList &second,DblList &result);
    void judgeMultiply(int temp,int &k,DblList &newdnode);
    void InitSpecial(DblList &first);
    void mulDnode(DblList &result,DblList &assist,int t);
    void multiplication(DblList &first,DblList &second,DblList &result);
    
    //view
    void prtWelcomeUI();
    void prtMainUI();
    void prtInputFormatUI(int op);

     

     

    view.cpp

     

    //
    // Created by Admin on 2017/3/31.
    //
    
    #include "big_num_op.h"
    
    void prtWelcomeUI(){
        system("CLS");
        printf("\n");
        printf("************************ Long Integer Arithmetic Unit ************************\n");
        printf("******************************************************************************\n");
        printf("*************************** Input any key to enter ***************************\n");
        printf("******************************************************************************\n");
        if(getch()){
            prtMainUI();
            return;
        }
        else {
            prtWelcomeUI();
            return;
        }
    }
    
    void prtMainUI(){
        system("CLS");
        time_t timep;
        struct tm *p;
        time(&timep);
        p = localtime(&timep); //获取系统时间
        printf("%d/%d/%d\n",p->tm_year+1900,p->tm_mon+1,p->tm_mday);
        printf("=====================================Menu=====================================\n");
        printf("             1.addition            2.subtraction        3.multiplication\n");
        printf("             4.division            5.power              0.exit\n");
        printf("==============================================================================\n");
        printf("Please select the operation[1-10]: ");
        return;
    }
    
    void prtInputFormatUI(int op){
        switch (op){
            case 1:
                printf("\n===================================Addition===================================\n");
                break;
            case 2:
                printf("\n=================================Subtraction==================================\n");
                break;
            case 3:
                printf("\n================================Multiplication================================\n");
                break;
            case 4:
                printf("\n===================================Division===================================\n");
                break;
            case 5:
                printf("\n====================================Power=====================================\n");
                break;
            default:
                return ;
        }
        printf("\texample\t1,2345,6789;\t-1,0001,0001;\n");
        printf("==============================================================================\n\n");
    }
    

     

     

     

     

     

    algorithm.cpp

     

    //
    // Created by Admin on 2017/3/31.
    //
    
    #include "big_num_op.h"
    
    //初始化带头结点的双向循环链表
    void InitList(DblList &first){
        first=(DblNode *)malloc(sizeof(DblNode));  //创建头结点
        if(!first){
            printf("\n内存分配失败!\n");
            exit(1);
        }
        first->data=0;  //头结点存储该长整数的总位数,初始化为0
        first->prior=first->next=first;
    }
    
    void DestroyList(DblList &first){
        DblList q,p=first->next;
        while (p!=first){
            q=p;
            p=p->next;
            free(q);
        }
        free(first);
    }
    
    //清空带头结点的双循环链表(保留头结点)
    void ClearList(DblList &first){
        DblList q,p=first->next;
        while (p!=first){
            q=p;
            p=p->next;
            free(q);
        }
        first->data=0;
        first->prior=first->next=first;
    }
    
    //计算带头结点的双向循环链表的长度
    int ListLength(DblList first){
        DblList p=first->next;
        int count=0;
        while(p!=first){
            p=p->next;
            count++;
        }
        return count;
    }
    
    //遍历循环链表
    void TravelList(DblList first){
        printf("\n===========================Testing============================\n");
        DblList p=first->next;
        while (p!=first){
            if(p->next==first)
                printf("%4d",p->data);
            else
                printf("%4d,",p->data);
            p=p->next;
        }
        printf(";\tthe number of node: %d\n",first->data);
        getchar();
        if(getch())return;
    }
    
    //按格式输出循环链表
    void PrtList(DblList first){
        printf("\n============================Print=============================\n");
        DblList p=first->next;
        if(first->data<0)printf("-");
        else printf("+");
        while (p!=first){
            if(p->next==first){
                if(p->data>=1000)printf("%4d",p->data);
                if(p->data<1000 && p->data>=100)printf("0%d",p->data);
                if(p->data<100 && p->data>=10)printf("00%d",p->data);
                if(p->data<10)printf("000%d",p->data);
            }
            else{
                if(p->data>=1000)printf("%4d,",p->data);
                if(p->data<1000 && p->data>=100)printf("0%d,",p->data);
                if(p->data<100 && p->data>=10)printf("00%d,",p->data);
                if(p->data<10)printf("000%d,",p->data);
            }
            p=p->next;
        }
        printf(";\tthe number of node: %d\n",first->data);
        if(getch())return;
    }
    
    //存储输入的长整数
    void InputInteger(DblList &first,DblList &second){
        printf("Hint:the input format is showed as above(\";\"to the end)\n");
        char str[3][8]={"first","second"};
        DblList assist;
        for (int i = 0; i < 2; ++i) {
            if(i==0)assist=first;
            else assist=second;
            printf("Please input the %s integer : ",str[i]);
            DblList newdnode,p;
            int temp,flag=1;
            char ch;
            scanf("%d",&temp);
            if(temp<0){  //读取第一个结点数据,处理正负数,存储的长整数的正负与头结点data的正负一致
                assist->data--;
                flag=0;
            }
            else assist->data++;
            //创建第一个结点并插入链尾
            newdnode=(DblNode *)malloc(sizeof(DblNode));
            newdnode->data=abs(temp);  //结点数值为正,符号位存于头结点,与头结点data域的正负一致
            assist->next=newdnode;
            newdnode->next=assist;
            newdnode->prior=assist;
            assist->prior=newdnode;
    
            p=newdnode;  //p为链尾结点
    
            scanf("%c",&ch);  //判断输入是否结束
            if(ch==';')continue;
            while (scanf("%d",&temp)){  //读取第二个结点到最后一个结点
                newdnode=(DblNode *)malloc(sizeof(DblNode));  //创建新结点并插入链尾
                newdnode->data=temp;
                newdnode->next=assist;
                newdnode->prior=p;
                p->next=newdnode;
                assist->prior=newdnode;
                if(flag)assist->data++;  //更新链的长度
                else assist->data--;
                p=newdnode;  //使p指向链尾
                scanf("%c",&ch);
                if(ch==';')break;
                else if(ch==',')continue;
                else {
                    printf("\nInput Error!\n");
                    getchar();
                    if(getch())exit(0);
                    return;
                }
            }
        }
        return;
    }
    
    //头结点的下一个位置插入新结点
    void newdnodeInset(DblList &p3,DblList &newdnode,DblList &result){
        p3->prior=newdnode;
        result->next=newdnode;
        newdnode->next=p3;
        newdnode->prior=result;
        p3=newdnode;
    }
    
    //加法进位处理
    void judgeAdd(int temp,int &k,DblList &newdnode){
        if(temp/10000==0){
            newdnode->data=temp;
            k=0;
        }
        else{
            newdnode->data=temp%10000;
            //k=temp/10000;
            k=1;
        }
    }
    
    //加法
    void addition(DblList &first,DblList &second,DblList &result){
        int len1=abs(first->data),len2=abs(second->data);
        int len=max(len1,len2);
        int smb1=first->data/abs(first->data),smb2=second->data/abs(second->data);  //取符号位(判断正负)
        //p1:指向first当前运算结点(初始化为链尾结点),p2:指向second当前运算结点(初始化为链尾结点)
        DblList newdnode,p1=first->prior,p2=second->prior,p3=result;  //p3:指向result当前运算结点(初始化为链尾结点)
    
        if(smb1+smb2!=0){  //两数都为正的情况 或 两数都为负的情况(负的情况可以转换为正的情况计算)
            int k=0,temp,i;  //k:记录进位  temp:储存计算的临时结果
            for (i = 0; i < len; i++) {  //从最低位开始计算(即从链尾开始向前求加)
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                if(p1!=first && p2!=second){  //如果两条链均未计算到头结点
                    temp=p1->data+p2->data+k;
                    judgeAdd(temp,k,newdnode);
                    p1=p1->prior;   //使指针指向下一个要计算的结点(指向高位)
                    p2=p2->prior;   //使指针指向下一个要计算的结点(指向高位)
                }
                else if(p1!=first && p2==second){  //如果second链已算到头结点,而first未到
                    temp=p1->data+k;
                    judgeAdd(temp,k,newdnode);
                    p1=p1->prior;  //使指针指向下一个要计算的结点(指向高位)
                }
                else if(p1==first && p2!=second){  //如果first链已算到头结点,而second未到
                    temp=p2->data+k;
                    judgeAdd(temp,k,newdnode);
                    p2=p2->prior;   //使指针指向下一个要计算的结点(指向高位)
                }
                //头结点的下一个位置插入新结点
                newdnodeInset(p3,newdnode,result);
            }
            while(k){  //处理最高位计算需要进位的情况
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                i++;
                temp=k;
                judgeAdd(temp,k,newdnode); //判断是否需要进位
                //头结点的下一个位置插入新结点
                newdnodeInset(p3,newdnode,result);
            }
            //两数为正的情况
            if(smb1+smb2>0)result->data=i; //储存链表长度(数位总数),结果的正负与该值一致
            //两数为负的情况
            if(smb1+smb2<0)result->data=-i;  //储存链表长度(数位总数),结果的正负与该值一致
            return;
        }
    
        if(smb1+smb2==0){  //一正一负的情况,交由减法函数进行处理
            if(smb1>0){  //first为正
                second->data=abs(second->data);
                subtraction(first,second,result);
                second->data=-second->data;  //恢复second的符号位
            }
            else{
                first->data=abs(first->data);
                subtraction(second,first,result);
                first->data=-first->data;  //恢复first的符号位
            }
            return;
        }
    }
    
    //减法借位处理
    void judgeSub(int temp,int &k,DblList &newdnode){
        if(temp>=0){  //不需要借位
            newdnode->data=temp;
            k=0;
        }
        else{  //需要借位
            newdnode->data=temp+10000;
            k=1;
        }
    }
    
    //比较长度相等的两个数,哪个较大
    int cmpInteger(DblList first,DblList second){
        DblList p1=first->next,p2=second->next;
        while(p1!=first){
            if(p1->data==p2->data){
                p1=p1->next;
                p2=p2->next;
                continue;
            }
            else if(p1->data>p2->data)return 1;
            else if(p1->data<p2->data)return -1;
        }
        return 0;
    }
    
    //减法结点数值相减处理
    void subDnode(int len,DblList &first,DblList &second,DblList &result,int &i){  //函数调用时,fisrt传入值比second传入大
        DblList newdnode,p1=first->prior,p2=second->prior,p3=result;  //first和second的计算均从链尾结点开始(即从最低位开始计算)
        int temp,k=0;  //k:初始借位为0
        for (i = 0; i < len; i++) {  //循环次数为两个数的最大长度
            newdnode=(DblNode *)malloc(sizeof(DblNode));
            if(p1!=first && p2!=second){  //如果两个指针均未到头结点
                temp=p1->data-p2->data-k;
                judgeSub(temp,k,newdnode);  //判断是否需要借位,并且为新结点赋值
                p1=p1->prior;  //使指针指向下一个要计算的结点(指向高位)
                p2=p2->prior;  //使指针指向下一个要计算的结点(指向高位)
            }
            else {  //如果p2已到头结点,而p1未到头结点
                temp=p1->data-k;
                judgeSub(temp,k,newdnode);
                p1=p1->prior;
            }
            //头结点的下一个位置插入新结点
            newdnodeInset(p3,newdnode,result);  //在结果链表result中插入计算得到的新结点
        }
    }
    
    //减法
    void subtraction(DblList &first,DblList &second,DblList &result){
        int len1=abs(first->data),len2=abs(second->data);
        int smb1=first->data/abs(first->data),smb2=second->data/abs(second->data);  //取符号位(判断正负)
        //p3:指向result当前运算结点(初始化为链尾结点)
        DblList newdnode,p3=result;
        if(smb1+smb2>0){  //两数都为正的情况
            int i,flag;  //flag:标记结果的正负; i:标记结果的链表长度
            if(len1>len2){  //如果第一个数的长度大于第二个
                flag=1;  //相减结果为正
                subDnode(len1,first,second,result,i); //两数相减,结果存于result中
            }
            if(len1<len2){  //如果第二个数长度大于第一个
                flag=-1;  //相减结果为负
                subDnode(len2,second,first,result,i);  //两数相减,结果存于result中
            }
            if(len1==len2){  //如果两个数的长度相等,则比较哪个数更大
                if(cmpInteger(first,second)>0){  //如果first>second
                    subDnode(len1,first,second,result,i); //调用时向参数first传入较大值first
                    flag=1;  //相减结果为正
                }
                if(cmpInteger(first,second)<0){  //如果first<second
                    subDnode(len2,second,first,result,i);  //调用时向参数first传入较大值second
                    flag=-1;  //相减结果为负
                }
                if(cmpInteger(first,second)==0){  //如果两个数相等
                    newdnode=(DblNode *)malloc(sizeof(DblNode));
                    newdnode->data=0;  //相减结果为0;
                    newdnodeInset(p3,newdnode,result);
                    flag=1;  //计算结果为正
                    i=1;
                }
            }
            //处理计算结果的正负及链表长度
            if(flag==1)result->data=i;
            else result->data=-i;
            return;
        }
        if(smb1+smb2<0){  //两个都为负的情况,可转换为两个为正相减的情况
            //转换为两个正数相减
            first->data=abs(first->data);
            second->data=abs(second->data);
            subtraction(second,first,result); //递归调用subtraction函数处理
            //恢复两个数符号位的正负情况
            first->data=-first->data;
            second->data=-second->data;
            return;
        }
        if(smb1+smb2==0){  //一正一负
            if(first->data>0 && second->data<0){  //first为正second为负的情况
                second->data=abs(second->data);  //转换为两个正数相加
                addition(first,second,result);  //交由加法函数进行处理
                second->data=-second->data;  //恢复原输入数据的符号位的正负情况
            }
            if(first->data<0 && second->data>0){  //second为正first为负的情况
                first->data=abs(first->data); //转换为两个正数相加
                addition(first,second,result);  //交由加法函数进行处理
                first->data=-first->data;  //恢复原输入数据的符号位的正负情况
                result->data=-result->data;  //两数相减结果为负
            }
            return;
        }
    }
    
    //乘法进位处理
    void judgeMultiply(int temp,int &k,DblList &newdnode){
        if(temp/10000==0){
            newdnode->data=temp;
            k=0;
        }
        else{
            newdnode->data=temp%10000;
            k=temp/10000;
        }
    }
    
    //初始化链表数值为0;
    void InitSpecial(DblList &first){
        DblList newdnode=(DblNode *)malloc(sizeof(DblNode));
        newdnode->data=0;
        newdnode->next=newdnode->prior=first;
        first->next=first->prior=newdnode;
        first->data=1;
    }
    
    //乘法结点相加处理
    void mulDnode(DblList &result,DblList &assist,int t){
        DblList newdnode,p1=result,p2=assist->prior;
        int temp,k=0;
        while(t--)
            p1=p1->prior;  //处理起始相加位置
        while (p2!=assist){
            if(p1->prior!=result){
                temp=p1->prior->data+p2->data+k;
                judgeMultiply(temp,k,p1->prior);
                p1=p1->prior;
            }
            else{
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                temp=p2->data+k;
                judgeMultiply(temp,k,newdnode);
                newdnodeInset(p1,newdnode,result);
                result->data++;
            }
            p2=p2->prior;
        }
        while(k) {  //处理最高位计算需要进位的情况
            newdnode = (DblNode *) malloc(sizeof(DblNode));
            temp = k;
            judgeMultiply(temp, k, newdnode); //判断是否需要进位
            //头结点的下一个位置插入新结点
            newdnodeInset(p1, newdnode, result);
            result->data++;
        }
    }
    
    //乘法
    void multiplication(DblList &first,DblList &second,DblList &result){
        int smb1=first->data/abs(first->data),smb2=second->data/abs(second->data);  //取符号位(判断正负)
    
        DblList assist;  //辅助计算链表,存储临时计算结果
        InitList(assist);  //初始化辅助链表
        InitSpecial(result); //初始化result数值为0,长度为1;
        DblList newdnode,p1,p2=second->prior,p4;
    
        int temp,i=0,t; //temp:储存临时结果  t:处理起始相加位置
        while(p2!=second){
            t=i++;
            int k=0;
            p1=first->prior;
            p4=assist;
            while (p1!=first){
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                temp=p2->data*p1->data+k;
                judgeMultiply(temp,k,newdnode);
                newdnodeInset(p4,newdnode,assist);
    
                assist->data++;  //每添加一个新的结点,辅助链表长度+1
                p1=p1->prior;
            }
            p2=p2->prior;
            while(k){  //处理最高位计算需要进位的情况
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                temp=k;
                judgeMultiply(temp,k,newdnode); //判断是否需要进位
                //头结点的下一个位置插入新结点
                newdnodeInset(p4,newdnode,assist);
                assist->data++;
            }
            mulDnode(result,assist,t);
            ClearList(assist);
        }
        if(smb1+smb2==0)result->data=-result->data;
        else result->data=abs(result->data);
        return;
    }
    
    /*
    //乘法
    void multiplication(DblList &first,DblList &second,DblList &result){
        int len1=abs(first->data),len2=abs(second->data);
        int smb1=first->data/abs(first->data),smb2=second->data/abs(second->data);  //取符号位(判断正负)
    
        DblList assist1,assist2;  //辅助计算链表,存储临时计算结果
        InitList(assist1);  //初始化辅助链表1
        InitList(assist2);  //初始化辅助链表2
        InitSpecial(assist2); //初始化辅助链表2数值为0,长度为1;
        DblList newdnode,p1,p2=second->prior,p4;
    
        int temp,t; //temp:储存临时结果  t:处理补0操作(需要添加多少个结点的0)
        for (int i = 0; i < len2; ++i) {
            t=i;
            int k=0;  //k:记录进位
            p4=assist1;
            p1=first->prior;
            for (int j = 0; j < len1; ++j) {
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                temp=p2->data*p1->data+k;
                judgeMultiply(temp,k,newdnode);
                newdnodeInset(p4,newdnode,assist1);
    
                assist1->data++;  //每添加一个新的结点,辅助链表长度+1
                p1=p1->prior;
            }
            p2=p2->prior;
            while(k){  //处理最高位计算需要进位的情况
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                assist1->data++;
                temp=k;
                judgeMultiply(temp,k,newdnode); //判断是否需要进位
                //头结点的下一个位置插入新结点
                newdnodeInset(p4,newdnode,assist1);
            }
            while(t--){  //补0操作:在辅助链表assist链尾补0
                newdnode=(DblNode *)malloc(sizeof(DblNode));
                newdnode->data=0;
                newdnode->prior=assist1->prior;
                newdnode->next=assist1;
                assist1->prior->next=newdnode;
                assist1->prior=newdnode;
    
                assist1->data++;  //每添加一个新的结点,辅助链表长度+1
            }
            addition(assist2,assist1,result);
            if(i+1<len2){
                //交换assist2和result两个链表
                DblList exchange=assist2;
                assist2=result;
                result=exchange;
                ClearList(result);
                ClearList(assist1);
            }
            else{
                DestroyList(assist1);
                DestroyList(assist2);
            }
        }
        if(smb1+smb2==0)result->data=-result->data;
        else result->data=abs(result->data);
        return;
    }
    */
    
    /*
    //转换为字符串
    void toString(DblList first,int &a[]){
        DblList p1=first->next;
        int i=0;
        while (p1!=first){
            a[i++]=p1->data;
        }
    }
    
    //除法
    void division(DblList &first,DblList &second,DblList result){
        int len1=abs(first->data),len2=abs(second->data);
        int smb1=first->data/abs(first->data),smb2=second->data/abs(second->data);  //取符号位(判断正负)
    
        int a[10000],b[10000];
    
    }
     */

     

     

    main.cpp

     

    #include "big_num_op.h"
    
    int main(){
        prtWelcomeUI();
        DblList first,second,result;
        int op;
        InitList(first);
        InitList(second);
        InitList(result);
        for (;;) {
            scanf("%d",&op);
            if(op==0)break;
            if(op<0||op>5){
                system("cls");
                prtMainUI();
                continue;
            }
            switch (op){
                case 1:
                    prtInputFormatUI(op);
                    InputInteger(first,second);
                    //TravelList(first); //testing 测试输入数据
                    //TravelList(second);
                    PrtList(first);
                    PrtList(second);
                    addition(first,second,result);
                    PrtList(result);
                    break;
                case 2:
                    prtInputFormatUI(op);
                    InputInteger(first,second);
                    PrtList(first);
                    PrtList(second);
                    subtraction(first,second,result);
                    PrtList(result);
                    break;
                case 3:
                    prtInputFormatUI(op);
                    InputInteger(first,second);
                    PrtList(first);
                    PrtList(second);
                    multiplication(first,second,result);
                    PrtList(result);
                    break;
                case 4:
                    prtInputFormatUI(op);
                    InputInteger(first,second);
                    break;
                case 5:
                    prtInputFormatUI(op);
                    InputInteger(first,second);
                    break;
                default:
                    return 0;
            }
            ClearList(first);
            ClearList(second);
            prtMainUI();
        }
        return 0;
    }

     

     

     

     

     

    展开全文
  • **【问题描述】**设计一个程序实现两个任意长的整数运算。 【基本要求】 (1)要求基于int类型实现任意长度整数。 (2)设计方案尽可能高效:运算快、所耗内存小。 (3)代码完成后需进行正确性和可用性测试。 ...

    一、需求分析

    【问题描述】设计一个程序实现两个任意长的整数运算。
    【基本要求】
    (1)要求基于int类型实现任意长度整数。
    (2)设计方案尽可能高效:运算快、所耗内存小。
    (3)代码完成后需进行正确性和可用性测试。
    【逻辑操作】
    1、构造一个空的任意长度整数
    2、在任意长度整数中插入一个新的数据元素
    3、在任意长度整数中删除 一个数据元素
    4、任意长度整数的 加法
    5、输出任意长度整数。
    【输入输出要求】

    1. 加数和被加数从Addent.txt和Augent.txt文件中获得,相加结果写入Sum.txt文件中。
    2. 要插入的数从Insert.txt中获得,插入位置由Position.txt中获得,结果写入Number.txt中。
    3. 要删除的数从Remove.txt中获得,删除位置由Position.txt中获得,结果写入Rest.txt中。
    4. 在性能测试中,加和函数的时间和空间数据写入Add性能测试.txt中,插入函数的时间和空间数据写入Insert性能测试.txt中,删除函数的时间和空间数据写入Remove性能测试.txt中。

    二、概要设计

    一、选择采用带头结点的双向循环链表;

    在这里插入图片描述

    双向循环链表类的定义:

    template<class T>
    struct DblNode           //链表节点类定义
    {
    	T data;                 //链表结点数据
    	DblNode<T> *lLink, *rLink;    //链表前驱、后继指针
    	DblNode(DblNode<T> *left=NULL,DblNode<T>*right=NULL):lLink(left),rLink(right){}    //构造函数
    	DblNode(T value,DblNode<T>*left=NULL,DblNode<T>*right=NULL):data(value),lLink(left),rLink(right){}  //构造函数
    };
    template<class T>
    class DblList{
    public:
    	DblList(T uniqueVal);
    	void Clear();//删除链表,释放空间
    	int Length()const;
    	bool IsEmpty() { return first->rLink == first; }
    	void setHead(DblNode<T>*ptr) { first = ptr; }
    	DblNode<T>*Search(const T&x);
    	DblNode<T>*Locate(int i, int d);
    	bool Insert(int i, const T&x, int d);
    	bool Remove(int i, T&x, int d);
    	//bool print();
    	void CreatDblList( string str);//用从文件中读出的字符串初始化链表
    	void Insert(const int&x);       //向链表尾部插入值为x的结点
    	void show(ostream &os);   //将链表写入文件中
    	DblList<T>*Add(DblList<T>*p,DblList<T>*q);  //加法
    	DblList<T>*Sub(DblList<T>*p, DblList<T>*q);  //减法
    	DblList<T>*Solve(DblList<T>*p, DblList<T>*q);   //根据符号判断是做加法还是减法
    	DblList<T>*compare(DblList<T>*p, DblList<T>*q);  //比较大小,以此判断被减数
    	void print();
    private:
    	DblNode<T>*first;
    };
    
    

    二、功能的逻辑设计
    1.从文件中读取大数,存入字符串中,再将字符串中的字符一个一个插入链表中。
    2.我们的大数的正负号存于first头结点的数据中,令起始的数值为0,如果大数为负数,我们将first结点的值置为1,并抹去字符串中的符号,以方便计算。
    2.加法功能:我们首先比较两个链表的first中的值是否一致,若一致则说明符号相同,进行加法运算;若不一致则进行减法运算,在减法运算之前我们还判断两数大小,结果的符号和数值大的那个数一致,并且数值大的那个数做被减数,数值小的那个做减数,以此来保证我们链表中的结点不会出现负号。
    3.插入和删除功能:首先对操作的位置进行定位,使用current指针,指向要操作的位置,再进行插入或删除操作。

    三、详细设计

    long int typecount = 0;    //计算程序所需字节数,在性能测试中用到
    

    “双向循环链表.h”

    1.构造函数

    template<class T>
    DblList<T>::DblList(T uniqueVal) {
    	first = new DblNode<T>(uniqueVal);
    	if (first == NULL) { cerr << "存储分配错误!" << endl; exit(1); }
    	first->rLink = first->lLink = first;
    //因为最终会清除first结点,所以此处不计入内存
    }
    
    

    2.释放空间函数//主要在性能测试中防止内存不够而使用

    template<class T>
    void DblList<T>::Clear()//清除
    {
    	DblNode<T>* curr = first->rLink;
    	while (curr!=first)
    	{
    		DblNode<T>* del = curr;
    		curr = curr->rLink;
    		delete del;
    		del = NULL;
    	}
    	delete first;
    }
    
    

    3.长度函数

    template<class T>
    int DblList<T>::Length()const {
    	DblNode<T>*current = first->rLink; int count = 0;
    	while (current != first) { current = current->rLink; count++; }
    	typecount += 4;
    	return count;
    }
    
    

    4.搜索函数

    template<class T>
    DblNode<T>*DblList<T>::Search(const T&x) {
    	DblNode<T>*current = first->rLink;
    	typecount += 4;
    	while (current != first && current->data != x)
    		current = current->rLink;
    	if (current != first)
    		return current;   //搜索成功
    	else
    	{
    		return NULL;     //搜索失败
    	}
    }
    
    

    5.定位函数

    template<class T>
    DblNode<T>*DblList<T>::Locate(int i, int d) {
    	DblNode<T>* current=new DblNode<T>();
    	//typecount += 4; //在最后删除了这个new出来的结点,故不计入内存
    	if (first->rLink == first || i == 0)
    		return first;
    	else {
    		if (d == 0) current = first->lLink;
    		else
    			current = first->rLink;
    		for (int j = 1; j < i; j++)
    			if (current == first)break;
    			else
    			{
    				if (d == 0)current = current->lLink;
    				else
    				{
    					current = current->rLink;
    				}
    			}
    		if (current != first)return current;
    		else
    		{
    			return NULL;
    		}
    	}
    	delete current;
    }
    
    

    6.链表初始化函数

    //初始化链表,并将字符串转换成整数
    template<class T>
    void DblList<T>::CreatDblList(string str)
    {
    
    	DblNode<T>*curr=first;
    	int len = str.length();
    	typecount += 8;
    	if (str[0] == '-')
    	{
    		first->data = 1;
    		str.erase(0, 1);
    		len--;
    	}
    	
    	for (int i =0; i < len; i++)
    	{
    		Insert(str[i]-'0');  //新建链表时主要调用插入函数一
    		//typecount = typecount + 4 * len;
    //最后会清除链表,故不计入内存
    	}
    }
    
    

    7.插入函数一

    //新建链表时在链表末端插入结点
    template<class T>
    void DblList<T>::Insert(const int&x) {
    	DblNode<T> *curr = first->lLink;
    	DblNode<T> *newNode = new DblNode<T>(x);
    	assert(newNode != NULL);
    
    	newNode->rLink = first;
    	newNode->lLink = curr;
    	curr->rLink = newNode;
    	first->lLink = newNode;
    	typecount += 8;
    }
    
    

    8.插入函数二

    //在已有的链表中可选择位置进行插入
    template<class T>
    bool DblList<T>::Insert(int i, const T&x, int d)
    {
    		DblNode<T>*current = Locate(i, d);
    		if (current == NULL)return false;
    		DblNode<T>*newNode = new DblNode<T>(x);
    		typecount += 8;
    		if (newNode == NULL) { cerr << "存储分配失败!" << endl; exit(0); }
    		if (d == 0)                                     //前驱插入
    		{
    			newNode->lLink = current->lLink;
    			current->lLink = newNode;
    			newNode->lLink->rLink = newNode;
    			newNode->rLink = current;
    		}
    		else {                                         //后继插入
    			newNode->rLink = current->rLink;
    			current->rLink = newNode;
    			newNode->rLink->lLink = newNode;
    			newNode->lLink = current;
    		}
    	return true;
    }
    
    

    9.删除函数

    template<class T>
    bool DblList<T>::Remove(int i, T&x, int d) {
    	DblNode<T>*current = Locate(i, d);
    	//typecount += 4;
    	if (current == NULL)return false;
    	current->rLink->lLink = current->lLink;
    	current->lLink->rLink = current->rLink;
    	x = current->data; delete current;
    	return true;
    }
    
    

    10.写入文件函数

    //将结果写入文件中   
    template<class T>
    void DblList<T>::show(ostream &os) {
    	typecount += 8;
    	int len = 0;
    	DblNode<T> *tmp = first->rLink;
    	while (tmp != first) {
    		len++;
    		tmp = tmp->rLink;
    	}
    	tmp = first;
    	tmp = tmp->rLink;
    	if (first->data == 1)os << '-';
    	while (tmp != first) {
    		if (tmp == first->rLink&&tmp->data == 0)
    			tmp = tmp->rLink;
    		else {
    			os << tmp->data;
    			tmp = tmp->rLink;
    		}
    	}
    }
    
    

    11.输出函数

    // 输出链表的结果
    template<class T>
    void DblList<T>::print()
    {
    	int len = 0;
    	DblNode<T> *tmp = first->rLink;
    	while (tmp != first) {
    		len++;
    		tmp = tmp->rLink;
    	}
    	tmp = first->rLink;
    	if (first->data == 1) cout << '-';
    	while (tmp != first) {
    		if (tmp==first->rLink&&tmp->data == 0)
    			tmp = tmp->rLink;
    		else {
    			cout << tmp->data;
    			tmp = tmp->rLink;
    		}
    	}
    	typecount += 8;
    	cout << endl;
    }
    
    

    12.加减选择函数,依加数和被加数的符号而定,符号相同做加法,符号相异做减法

    template<class T>
    DblList<T>*DblList<T>::Solve(DblList<T>*p, DblList<T>*q)
    {
    	if (p->first->data == q->first->data)
    		return Add(p, q);
    	else
    		return Sub(p, q);
    }
    
    

    13.加法函数

    // 做加法
    template<class T>
    DblList<T>*DblList<T>::Add(DblList<T>* p,DblList<T>* q)
    {
    	DblNode<T>*current1 = p->first->lLink;
    	DblNode<T>*current2 = q->first->lLink;
    	int e = 0;   //记录进位
    	typecount += 12;
    	if (p->Length() >= q->Length())
    	{
    		while (current2 != q->first)
    		{
    			int	temp = current1->data + current2->data+e;
    			if (temp > 9)
    			{
    				current1->data = temp % 10;
    				e=1;
    			}
    			else
    			{
    				current1->data = temp;
    				e=0;
    			}
    			current1 = current1->lLink;
    			current2 = current2->lLink;
    		}
    		while (current1 != p->first)
    		{
    			int temp = current1->data + e;
    			if (temp > 9)
    			{
    				current1->data = temp % 10;
    				e = 1;
    			}
    			else
    			{
    				current1->data = temp;
    				e = 0;
    			}
    			current1 = current1->lLink;
    		}
    		if (e)
    		{
    			p->Insert(0, e, 1);
    		}
    		return p;
    	}
    	else
    	{
    		while (current1 != p->first)
    		{
    			int temp = current1->data + current2->data+e;
    			if (temp > 9)
    			{
    				current1->data = temp % 10;
    				e = 1;
    			}
    			else
    			{
    				current1->data = temp;
    				e = 0;
    			}
    			current1 = current1->lLink;
    			current2 = current2->lLink;
    		}
    		while (current2 != q->first)
    		{
    			int temp = current2->data + e;
    			if (temp > 9)
    			{
    				current2->data = temp % 10;
    				e = 1;
    			}
    			else
    			{
    				current2->data = temp;
    				e = 0;
    			}
    			current2 = current2->lLink;
    		}
    		if (e)
    		{
    			q->Insert(0, e, 1);
    		}
    		return q;
    	}
    }
    
    

    14.两数大小比较函数,在做减法时使用

    template<class T>
    DblList<T>*DblList<T>::compare(DblList<T>*p, DblList<T>*q)
    {
    	if (p->Length() > q->Length())return p;
    	if (p->Length() < q->Length())return q;
    	
    	if (p->Length() == q->Length())
    	{
    		DblNode<T>*curr1 = p->first->rLink;
    		DblNode<T>*curr2 = q->first->rLink;
    		typecount += 8;
    		while (1)
    		{
    			if (curr1->data > curr2->data)return p;
    			if (curr2->data > curr1->data)return q;
    			if (curr1->data == curr2->data)
    			{
    				curr1 = curr1->rLink;
    				curr2 = curr2->rLink;
    			}
    			//if (curr1 == first)return p;
    		}
    	}
    }
    
    
    1. 减法函数
    // 做减法
    template<class T>
    DblList<T>*DblList<T>::Sub(DblList<T>* p, DblList<T>* q)
    {
    	DblNode<T>*current1 = p->first->lLink;
    	DblNode<T>*current2 = q->first->lLink;
    	int b = 0;           //借位记为b
    	typecount += 12;
    	if (this->compare(p, q) == p)
    	{
    		while (current2 != q->first)
    		{
    			if (current1->data - b < current2->data)
    			{
    				current1->data += 10;
    				current1->data = current1->data - b - current2->data;
    				b = 1;
    			}
    			else
    			{
    				current1->data = current1->data - b - current2->data;
    				b = 0;
    			}
    			current1 = current1->lLink;
    			current2 = current2->lLink;
    		}
    		return p;
    	}
    	else
    	{
    		while (current1 != p->first)
    		{
    			if (current2->data - b < current1->data)
    			{
    				current2->data += 10;
    				current2->data = current2->data - b - current1->data;
    				b = 1;
    			}
    			else
    			{
    				current2->data = current2->data - b - current1->data;
    				b = 0;
    			}
    			current1 = current1->lLink;
    			current2 = current2->lLink;
    		}
    		return q;
    	}
    }
    
    

    “AlgPerf.h”性能测试头文件

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include <windows.h>
    # include <iostream>
    #include <fstream>
    #include"双向循环链表.h"
    
    
    string str(const int len)     //生成字符串
    {
    	string str="";
    	int i;
    	for (i = 0; i < len; i++)
    	{
    		str += rand() % 10;
    	}
    	return str;
    }
    
    void AddTest()    //加法性能测试
    {
    	ofstream Add;
    	Add.open("Add性能测试.txt");
    	for (int j = 0; j < 120; j++)
    	{
    		int num = 10000 + 10000 * j;     
    		typecount = 0;
    		string a = str(num);
    		string b = str(num);
    		DblList<int> list1(0);
    		DblList<int> list2(0);
    		(&list1)->CreatDblList(a);
    		(&list2)->CreatDblList(b);
    		DblList<int>* listz(0);
    		LARGE_INTEGER freq;
    		LARGE_INTEGER startCount, endCount;
    		double elapsed;
    		QueryPerformanceFrequency(&freq);
    		QueryPerformanceCounter(&startCount);// 统计运行总时间
    		// 统计操作时间和累加空间字节数
    		for (int t = 0; t < 200; t++)
    		{
    			
    			listz = listz->Solve(&list1, &list2); 
    		}
    		// 停止计时器
    		QueryPerformanceCounter(&endCount);
    
    		// 返回计时器经过时间(单位:毫秒)
    		elapsed = (double)(endCount.QuadPart - startCount.QuadPart) / freq.QuadPart;
    		elapsed *= 1000;
    		Add << elapsed << "ms," << typecount;
    		Add << endl;
    		a.~basic_string();
    		b.~basic_string();
    		(&list1)->Clear();
    		(&list2)->Clear();
    		//listz->Clear();
    	}
    	Add.close();
    	
    
    }
    
    
    void InsertTest()    //插入性能测试
    {
    	ofstream Ins;
    	Ins.open("Insert性能测试.txt");
    	for (int j = 0; j < 120; j++)
    	{
    		int num = 10000 + 10000 * j;
    		typecount = 0;
    		string a = str(num);
    		DblList<int> listi(0);
    		(&listi)->CreatDblList(a);
    		//string b = str(num);
    		LARGE_INTEGER freq;
    		LARGE_INTEGER startCount, endCount;
    		double elapsed;
    		QueryPerformanceFrequency(&freq);
    		QueryPerformanceCounter(&startCount);// 统计运行总时间
    		// 统计操作时间和累加空间字节数
    		for (int t = 0; t < 200; t++)
    		{
    			
    			(&listi)->Insert(rand()%100, rand()%10, 1);
    		}
    		// 停止计时器
    		QueryPerformanceCounter(&endCount);
    
    		// 返回计时器经过时间(单位:毫秒)
    		elapsed = (double)(endCount.QuadPart - startCount.QuadPart) / freq.QuadPart;
    		elapsed *= 1000;
    		Ins << elapsed << "ms," << typecount;
    		Ins << endl;
    		a.~basic_string();
    		(&listi)->Clear();
    	}
    	Ins.close();
    }
    
    
    void RemoveTest()    //删除性能测试
    {
    	ofstream Rem;
    	Rem.open("Remove性能测试.txt");
    	for (int j = 0; j < 120; j++)
    	{
    		int num = 10000 + 10000 * j;
    		typecount = 0;
    		string a = str(num);
    		int b = 0; typecount += 4;
    		DblList<int> listr(0);
    		(&listr)->CreatDblList(a);
    		//string b = str(num);
    		LARGE_INTEGER freq;
    		LARGE_INTEGER startCount, endCount;
    		double elapsed;
    		QueryPerformanceFrequency(&freq);
    		QueryPerformanceCounter(&startCount);// 统计运行总时间
    		// 统计操作时间和累加空间字节数
    		for (int t = 0; t < 200; t++)
    		{
    			
    			(&listr)->Remove(100, b, 1);
    		}
    		// 停止计时器
    		QueryPerformanceCounter(&endCount);
    
    		// 返回计时器经过时间(单位:毫秒)
    		elapsed = (double)(endCount.QuadPart - startCount.QuadPart) / freq.QuadPart;
    		elapsed *= 1000;
    		Rem << elapsed << "ms," << typecount;
    		Rem << endl;
    		a.~basic_string();
    		(&listr)->Clear();
    	}
    	Rem.close();
    }
    

    “任意长度整数相加.cpp”

    #include<iostream>
    #include<stdlib.h>
    #include<string>
    #include <fstream>
    #include<assert.h>
    //#include"双向循环链表.h"
    #include"AlgPerf.h"
    using namespace std;
    
    
    
    int main()
    {
    	//性能测试
    	AddTest();
    	InsertTest();
    	RemoveTest();
    	cout << "Got it!" << endl;
    
    
    	//准确性测试
    	ifstream Augent, Addent, Pos, Insert,Remove;
    	ofstream Sum,Num,Rest;
    	string tmpAug, tmpAdd, tmpinsert, tmpPos,tmpRemove;
    	string a, b,in,re;
    	int r=0,ipos;
    	int count = 0;
    	Augent.open("Augent.txt");
    	Addent.open("Addent.txt");
    	Pos.open("Position.txt");
    	Insert.open("Insert.txt");
    	Remove.open("Remove.txt");
    	Num.open("Number.txt");
    	Sum.open("Sum.txt");
    	Rest.open("Rest.txt");
    	do {
    		if (Augent.is_open()) {
    			getline(Augent, tmpAug);
    		}
    		if (tmpAug.empty())
    			break;
    
    		if (Addent.is_open()) {
    			getline(Addent, tmpAdd);
    		}
    		if (tmpAdd.empty())
    			break;
    		if (Insert.is_open()) {
    			getline(Insert, tmpinsert);
    		}
    		if (tmpinsert.empty())
    			break;
    		if (Pos.is_open()) {
    			getline(Pos, tmpPos);
    			ipos = atoi(tmpPos.c_str());
    		}
    		if (Remove.is_open()) {
    			getline(Remove, tmpRemove);
    		}
    		if (tmpRemove.empty())
    			break;
    		
    		count++;
    		cout << count << endl;
    		a = tmpAug;
    		b = tmpAdd;
    		
    		DblList<int> list1(0);
    		DblList<int> list2(0);
    		(&list1)->CreatDblList(a);
    		(&list2)->CreatDblList(b);
    		DblList<int>* listz(0);
    	    listz=listz->Solve(&list1,&list2);   //求和测试
    	    listz->show(Sum);
    		Sum << endl;
    		cout << "求和结果为:";
    	    listz->print();
    		
    		DblList<int> listi(0);    //插入测试
    		in = tmpinsert;
    		(&listi)->CreatDblList(in);
    		(&listi)->Insert(ipos, 1, 1);
    		(&listi)->show(Num);
    		Num << endl;
    		cout << "插入结果为:";
    		(&listi)->print();
    
    		DblList<int> listr(0);    //删除测试
    		re = tmpRemove;
    		(&listr)->CreatDblList(re);
    		(&listr)->Remove(ipos, r, 1);
    		(&listr)->show(Rest);
    		Rest << endl;
    		cout << "删除结果为:";
    		(&listr)->print();
    	} while (1);
    	Augent.close();
    	Addent.close();
    	Num.close();
    	Pos.close();
    	Sum.close();
    	Insert.close();
    	Remove.close();
    	Rest.close();
    	
    	system("pause");
    	return 0;
    }
    
    

    四、文件列表

    文本文件列表:
    在这里插入图片描述

    程序相关文件列表:
    在这里插入图片描述

    展开全文
  • 其实说白了就是:定义带符号整数的,则可以存储正负整数定义无符号整数的,则只可以存储正整数。拓展资料:计算机里的数是用二进制表示的,最左边的这一位一般用来表示这个数是正数还是负数,这样的话这个数就是.....
  • 用双向链表实现超长整数加减法

    千次阅读 2015-04-11 22:46:00
    学校数据结构的课程实验...主要功能:对由用户输入的两个任意长的整数进行加减运算 主函数: 1 int main() 2 { 3 4 short num;//临时数据段 5 char optr;//运算符 6 char ch;//临时字符接收 7 char choice...
  • 自己编的可放大任意整数倍的最近邻插值 双线性插值 matlab代码
  • matlab做除法,怎么取整数?方法一: floor(a/b);就是舍去小数点。 ceil(a/b)就是舍去小数点+1的数。 方法二: fix(x)截尾取整 fix(x)不超过x的最大整数 ceil(x)大于x的最小整数 round(x)四舍五入取整 扩展资料: ...
  • python产生随机整数

    千次阅读 2020-12-13 14:28:04
    信息举报时间:2020-12-13 本页为您甄选多篇描写python产生随机整数,python产生随机整数精选,python产生随机整数大全,有议论,叙事 ,想象等形式。文章字数有400字、600字、800字....VB循环结构编写程序计算任意10...
  • python中整数大小限制

    2020-11-23 20:09:55
    我知道,在大多数编程语言中,如果不是所有的编程语言,整数、浮点数等等,它们都有最大的容量,它们要么没有符号,要么有符号。 pascal的整数型只能容纳32768~。 我想知道的是,python的int和浮点变量的限制是什么...
  • 浮点数转换为整数四舍五入Given a float value and we have to round the value to the nearest integer with the help of Macro in C language. 给定一个浮点值,我们必须借助C语言中的... 宏定义: #define ...
  • 给你一个二维整数数组 ranges 和两个整数 left 和 right 。每个 ranges[i] = [starti, endi] 表示一个从 starti 到 endi 的 闭区间 。 如果闭区间 [left, right] 内每个整数都被 ranges 中 至少一个 区间覆盖,那么...
  • 题目:设计一个实现任意长的整数的加法运算的演示程序一、需求分析本演示程序中,利用双向循环链表来实现长整数的储存,每个节点含一个整型变量。输入和输出形式按照中国对于长整数的表示习惯,每四位一组,组间用...
  • python整数和变量

    2019-05-07 23:23:13
    1.整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样。 2.浮点数 浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变...
  • 预定义变量 预定义变量是由系统本身定义的变量。 ans是默认赋值变量 i和j代表虚数单位 pi代表圆周率 NaN代表非数(作图时需要裁掉部分,把需要裁掉的部分的坐标设为NaN即可) 3.变量的管理 (1)内存变量的删除与修改 ...
  • 展开全部通过转换为字符串,再截取整数部分:float a = 1.1f;//定义一个浮点变量62616964757a686964616fe59b9ee7ad9431333433623763aString str = String.valueOf(a);//浮点变量a转换为字符串strint idx = str....
  • [Java教程]javascript浮点数转换成整数三种方法0 2014-06-24 04:00:27将浮点数转换成整数方法有很多,分享三种常用方法。Summary暂时我就想到3个方法而已。如果读者想到其他好用方法,也可以交流一下parseInt位...
  • python 基本数据类型之整数

    千次阅读 2019-05-26 15:44:28
    小数使用float , 但不像java中那样我定义一个整数是使用 int a = 10; 这个在python中编译器会报错的,因为python也是解释性语言,这点跟JavaScript很像,是在运行时期去查看这个变量是什么才能决定它是什么类型数据,...
  • 设计的思想主要是通过链表来实现的.利用链表的节点存储...通过对"+"号和"*"号的重载实现对大整数的加和乘.理论上可以实现N多位的运算,只要你的机器内存够大…程序的重点在于运算符的重载. 本程序主要由三个文件构
  • 1如何将字串 String 转换成整数 int?A. 有两个方法:1). int i = Integer.parseInt([String]); 或i = Integer.parseInt([String],[int radix]);2). int i = Integer.valueOf(my_str).intValue();注: 字串转成 Double,...
  • C++实现任意长度整数抽象数据类型

    千次阅读 2020-05-03 19:57:49
    用户根据提示,按格式输入两个任意长度的整数,经程序运算得出两个整数的和,并将结果输出在屏幕上。 程序执行的命令包括: (1)、程序运行,提示用户按格式输入数据; (2)、用户输入两个任意长度的整数; (3)...
  • c语言 整数和浮点数 C ++中的所有数字 ( All About Numbers in C++ ) In C++ there are two types of numbers. Ints and floats. There are also variants of these types that hold bigger numbers, or only ...
  • C++产生随机整数和随机浮点数

    千次阅读 2021-01-12 09:00:04
    头文件 ...随机整数 通用公式 a + rand() % n [a,b) 的随机整数 (rand() % (b-a))+ a [a,b]的随机整数 (rand() % (b-a+1))+ a; (a,b) 的随机整数 (rand() % (b-a))+ a + 1; 随机浮点数 [0
  • 子函数:输入字节整数。值保存在主调函数传递过来的变量中,非数字字符都是结束符。 ;入口参数:DS传递主调函数的段地址;DI传递字节变量的地址 ;用到的寄存器:ES,AX,DS,DI,SI,CX,BX,DX ;无符号字节整型的...
  • 求两个整数的最大值

    千次阅读 2020-03-30 19:44:58
    求两个整数的最大值 程序: #include<stdio.h>... //定义a,b,max为整型变量 printf("请输入两个整数a,b:\n"); //提示操作者要输入的内容 scanf("%d%d",&a,&b); //输入变量a,b的值 ...
  • 什么是精度浮点数

    千次阅读 2021-05-23 02:07:56
    问题一:什么是单、精度浮点数浮点就是小数点位置不确定,比如123.43,6557.521.在C语言中,一般单精度数据类型比如int,数据的范围是2的31次方,而精度类型的整型比如long int的数据范围是2的63次方.所以精度和单...
  • C++正整数的素数分解的实现算法C++正整数的素数分解的实现算法完整源码(定义,实现,main函数测试) C++正整数的素数分解的实现算法完整源码(定义,实现,main函数测试) #include <algorithm> #include <...
  • 任意长整数的加减乘运算 说明:设计一个程序实现两个任意长整数的加减乘运算。 操作环境:Visual Studio2019或Code::Blocks16.01 二、课程设计主要内容和要求 1.利用双向循环链表,设计一个实现任意长的整数进行加...
  • 有很多工程师喜欢自己封装一些标准库已有的函数,其实自己封装的函数,并不一定比标准库好,有时候反而代码更冗余,且有bug。...标准头文件包括: 一、标准定义()文件里包含了标准库的一些常用定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 219,937
精华内容 87,974
关键字:

双整数如何定义

友情链接: Book.rar