双整数如何定义

整数

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

收起

展开全文

长整数四则运算实验报告

2021-05-20 17:03:13

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


 数据结构
 课内实验报告书
 一、实验题目：长整数四则运算
 二、实验目的：
 通过本次实验，熟练掌握链表的存储结构及其各种基本运算，体会链表操作的特点。
 三、实验要求：
 设计一个实现任意长的整数进行加法运算的演示程序。
 要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。任何整形变量的范围是 -(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;
}

收起

展开全文

数据结构双向循环链表

C++使用双向循环链表实现两个任意长的整数运算

千次阅读 2020-03-13 16:53:45

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

一、需求分析 
【问题描述】设计一个程序实现两个任意长的整数运算。
 【基本要求】
 （1）要求基于int类型实现任意长度整数。
 （2）设计方案尽可能高效：运算快、所耗内存小。
 （3）代码完成后需进行正确性和可用性测试。
 【逻辑操作】
 1、构造一个空的任意长度整数
 2、在任意长度整数中插入一个新的数据元素
 3、在任意长度整数中删除 一个数据元素
 4、任意长度整数的 加法
 5、输出任意长度整数。
 【输入输出要求】 
加数和被加数从Addent.txt和Augent.txt文件中获得，相加结果写入Sum.txt文件中。
要插入的数从Insert.txt中获得，插入位置由Position.txt中获得，结果写入Number.txt中。
要删除的数从Remove.txt中获得，删除位置由Position.txt中获得，结果写入Rest.txt中。
在性能测试中，加和函数的时间和空间数据写入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;
		}
	}
}

 
减法函数 
// 做减法
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;
}

 
四、文件列表 
文本文件列表：
  
程序相关文件列表：

收起

展开全文

c++

无符号整数和有符号整数怎么区分？
千次阅读 2021-07-31 00:23:36
其实说白了就是：定义带符号整数的，则可以存储正负整数，定义无符号整数的，则只可以存储正整数。拓展资料：计算机里的数是用二进制表示的，最左边的这一位一般用来表示这个数是正数还是负数，这样的话这个数就是.....
收起
用双向链表实现超长整数加减法
千次阅读 2015-04-11 22:46:00
学校数据结构的课程实验...主要功能：对由用户输入的两个任意长的整数进行加减运算主函数： 1 int main() 2 { 3 4 short num;//临时数据段 5 char optr;//运算符 6 char ch;//临时字符接收 7 char choice...
收起
自编的可放大任意整数倍的最近邻插值和双线性插值函数
2012-03-06 20:47:11
自己编的可放大任意整数倍的最近邻插值双线性插值 matlab代码
收起
关于matlab中用什么字符表示任意整数
千次阅读 2021-04-18 06:05:38
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和浮点变量的限制是什么...
收起
浮点数转换为整数四舍五入_定义宏以将浮点值四舍五入为C中最接近的整数
千次阅读 2020-06-24 06:38:19
浮点数转换为整数四舍五入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 ...
收起
java 字符串 c++ 算法 stm32
【第 54 场双周赛】5767.检查是否区域内所有整数都被覆盖
2021-06-13 23:02:44
给你一个二维整数数组 ranges 和两个整数 left 和 right 。每个 ranges[i] = [starti, endi] 表示一个从 starti 到 endi 的闭区间。如果闭区间 [left, right] 内每个整数都被 ranges 中至少一个区间覆盖，那么...
收起
leetcode java 算法
数据结构：长整数的四则运算
2021-05-22 16:01:16
题目：设计一个实现任意长的整数的加法运算的演示程序一、需求分析本演示程序中，利用双向循环链表来实现长整数的储存，每个节点含一个整型变量。输入和输出形式按照中国对于长整数的表示习惯，每四位一组，组间用...
收起
python整数和变量
2019-05-07 23:23:13
1.整数 Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。 2.浮点数浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变...
收起
matlab 转换为正整数_【MATLAB】专题1笔记 MATLAB基础知识
千次阅读 2020-11-20 17:32:53
预定义变量预定义变量是由系统本身定义的变量。 ans是默认赋值变量 i和j代表虚数单位 pi代表圆周率 NaN代表非数(作图时需要裁掉部分，把需要裁掉的部分的坐标设为NaN即可) 3.变量的管理 (1)内存变量的删除与修改 ...
收起
matlab或
Java中怎么把浮点数转变成整数只保留整数部分
2021-01-14 13:54:23
展开全部通过转换为字符串，再截取整数部分：float a = 1.1f;//定义一个浮点变量62616964757a686964616fe59b9ee7ad9431333433623763aString str = String.valueOf(a);//浮点变量a转换为字符串strint idx = str....
收起
[Java教程]javascript浮点数转换成整数三种方法
千次阅读 2021-03-01 09:22:23
[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很像,是在运行时期去查看这个变量是什么才能决定它是什么类型数据,...
收起
[转]双链表实现大整数的加法与乘法[VC++]
千次阅读 2011-08-23 21:55:44
设计的思想主要是通过双链表来实现的.利用双链表的节点存储...通过对"+"号和"*"号的重载实现对大整数的加和乘.理论上可以实现N多位的运算,只要你的机器内存够大…程序的重点在于运算符的重载. 本程序主要由三个文件构
收起
vc++ rest null class 存储
JAVA数据类型转换如何将字串 String 转换成整数 int
2021-03-16 18:21:18
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语言整数和浮点数_C ++处理整数和浮点数
千次阅读 2020-09-13 17:08:46
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 ...
收起
java python c++ 编程语言 go
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
收起
c++ random 随机浮点数随机整数 rand
汇编源码学习13-子函数模块-输入双字节整数
千次阅读 2011-12-21 21:29:41
子函数：输入双字节整数。值保存在主调函数传递过来的变量中，非数字字符都是结束符。 ;入口参数：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的值 ...
收起
c语言
什么是双精度浮点数
千次阅读 2021-05-23 02:07:56
问题一：什么是单、双精度浮点数浮点就是小数点位置不确定,比如123.43,6557.521.在C语言中,一般单精度数据类型比如int,数据的范围是2的31次方,而双精度类型的整型比如long int的数据范围是2的63次方.所以双精度和单...
收起
c语言的双精度浮点数
C++正整数的素数分解的实现算法(附完整源码)
2021-03-18 10:47:22
C++正整数的素数分解的实现算法C++正整数的素数分解的实现算法完整源码（定义，实现，main函数测试） C++正整数的素数分解的实现算法完整源码（定义，实现，main函数测试） #include <algorithm> #include <...
收起
数据结构课程设计：任意长整数的加减乘运算（c++）
千次阅读 多人点赞 2021-01-06 14:26:52
任意长整数的加减乘运算说明：设计一个程序实现两个任意长整数的加减乘运算。操作环境：Visual Studio2019或Code::Blocks16.01 二、课程设计主要内容和要求 1．利用双向循环链表，设计一个实现任意长的整数进行加...
收起
数据结构链表
c语言随机生成整数存放一维数组_C语言常用标准库解读
2020-11-20 10:54:26
有很多工程师喜欢自己封装一些标准库已有的函数，其实自己封装的函数，并不一定比标准库好，有时候反而代码更冗余，且有bug。...标准头文件包括：一、标准定义()文件里包含了标准库的一些常用定义...
收起

整数

长整数四则运算实验报告

长整数四则运算_双向循环链表

C++使用双向循环链表实现两个任意长的整数运算

一、需求分析

二、概要设计

三、详细设计

四、文件列表

无符号整数和有符号整数怎么区分？

用双向链表实现超长整数加减法

自编的可放大任意整数倍的最近邻插值和双线性插值函数

关于matlab中用什么字符表示任意整数

python产生随机整数

python中整数大小限制

浮点数转换为整数四舍五入_定义宏以将浮点值四舍五入为C中最接近的整数

【第 54 场双周赛】5767.检查是否区域内所有整数都被覆盖

数据结构：长整数的四则运算

python整数和变量

matlab 转换为正整数_【MATLAB】专题1笔记 MATLAB基础知识

Java中怎么把浮点数转变成整数只保留整数部分

[Java教程]javascript浮点数转换成整数三种方法

python 基本数据类型之整数

[转]双链表实现大整数的加法与乘法[VC++]

JAVA数据类型转换如何将字串 String 转换成整数 int

C++实现任意长度整数抽象数据类型

c语言 整数和浮点数_C ++处理整数和浮点数

C++产生随机整数和随机浮点数

汇编源码学习13-子函数模块-输入双字节整数

求两个整数的最大值

什么是双精度浮点数

C++正整数的素数分解的实现算法(附完整源码)

数据结构课程设计：任意长整数的加减乘运算（c++）

c语言随机生成整数存放一维数组_C语言常用标准库解读

双整数如何定义

c语言整数和浮点数_C ++处理整数和浮点数