高精度模板

已于 2022-12-06 21:09:09 修改
阅读量357 收藏 1
点赞数 1
分类专栏： 模板 高精度 文章标签： 链表 数据结构
于 2018-07-29 21:26:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xumingyang0/article/details/81275780
版权

upd:程序设计课写了个链表实现的实数加减乘除，输入格式要严格按照程序结尾的数据来（嫌麻烦没有压位）

#include<bits/stdc++.h>
using namespace std;
#define gc getchar
#define pc putchar
typedef long long ll;
struct node{
	int x;
	struct node*pre,*ne;
};
void insert(node *p,int x){//p后插入x 
	node *q=new node;
	q->ne=p->ne;
	q->pre=p;
	p->ne->pre=q;
	p->ne=q;
	q->x=x;
}
node* del(node *p){
	p->ne->pre=p->pre;
	p->pre->ne=p->ne;
	node *q=p;
//	cout<<(q->x)<<endl;
	p=p->ne;
	delete q;
	return p;
}
struct NUM{
	int n,sgn,exp;
	node *head;
	char get(){
		char c=gc();
		int pos=-1;
		if (c=='-') sgn=-1,c=gc();
		else sgn=1;
		node*p=head=new node;
		p->pre=p->ne=p;
		do{
			if (c!='.'){
				n++;
				insert(p,c-'0');
				p=p->ne;
			}else pos=n;
			c=gc();
		}while('0'<=c&&c<='9' || c=='.');
		if (pos!=-1) exp=n-pos;
		else exp=0;
		return c;
	}
	void print(){
		node *p=head;
		if (sgn==-1) pc('-');
		int cnt=0;
		do{
			p=p->ne;
			printf("%d",p->x);
			cnt++;
			if (exp && cnt==n-exp) pc('.');
		}while(p->ne!=head);
		puts("");
	}
	void copy(NUM a){
		n=a.n,sgn=a.sgn,exp=a.exp;
		node *p=head=new node,*q=a.head;
		p->ne=p->pre=p;
		for (int i=0;i<n;i++) q=q->ne,insert(p,q->x),p=p->ne;
	}
	void destroy(){
		exp=sgn=0;
		node *p=head;
		while (n--) p=del(p);
		n=0;
		delete p;
	}
	void back(){
		node *p=head->ne;
		while (p->x==0 && n>exp+1) p=del(p),n--;
	}
	friend bool operator<(NUM a,NUM b){//小数点位置相同比较绝对值大小 
		if (a.n!=b.n) return a.n<b.n;
		node *p=a.head,*q=b.head;
		for (int i=0;i<a.n;i++){
			p=p->ne,q=q->ne;
			if (p->x!=q->x) return p->x<q->x;
		}
		return 0;
	}
	friend NUM operator+(NUM a,NUM b){
		NUM A,B;
		A.copy(a),B.copy(b);
		if (A.sgn!=B.sgn){
			B.sgn*=-1;
			int fl=A.sgn;
			A=A-B;
			A.sgn*=fl;
			B.destroy();
			return A;
		}
		if (A.exp>B.exp) swap(A,B);
		node *p=A.head->pre;
		for (int i=0;i<B.exp-A.exp;i++) A.n++,insert(p,0),p=p->ne;
		A.exp=B.exp;
		if (A.n<B.n) swap(A,B);
		p=A.head->pre;
		node *q=B.head->pre;
		bool fl=0;
		for (int i=0;i<A.n;i++){
			p->x+=(i<B.n?q->x:0)+fl;
			if (p->x>=10) fl=1,p->x-=10;
			else fl=0;
			p=p->pre,q=q->pre;
		}
		if (fl) insert(p,1),A.n++;
		B.destroy();
		return A;
	}
	friend NUM operator-(NUM a,NUM b){
		NUM A,B;
		A.copy(a),B.copy(b);
		if (A.sgn!=B.sgn){
			B.sgn*=-1;
			int fl=A.sgn;
			A=A+B;
			A.sgn*=fl;
			B.destroy();
			return A;
		}
		if (A.exp>B.exp) swap(A,B);
		node *p=A.head->pre;
		for (int i=0;i<B.exp-A.exp;i++) A.n++,insert(p,0),p=p->ne;
		A.exp=B.exp;
		if (A<B) swap(A,B),A.sgn*=-1;
		p=A.head->pre;
		node *q=B.head->pre;
		bool fl=0;
		for (int i=0;i<A.n;i++){
			p->x-=(i<B.n?q->x:0)+fl;
			if (p->x<0) fl=1,p->x+=10;
			else fl=0;
			p=p->pre,q=q->pre;
		}
		A.back();
		B.destroy();
		return A;
	}
	friend NUM operator*(NUM a,NUM b){
		NUM A,B,C;
		A.copy(a),B.copy(b);
		node *pc=C.head=new node;
		C.sgn=A.sgn*B.sgn;
		C.exp=A.exp+B.exp;
		C.n=A.n+B.n;
		pc->ne=pc->pre=pc;
		for (int i=0;i<A.n+b.n;i++) insert(pc,0),pc=pc->ne;
		node *p=A.head;
		for (int i=0;i<A.n;i++){
			p=p->pre,pc=C.head;
			for (int j=0;j<i;j++) pc=pc->pre;
			node *q=B.head;
			for (int j=0;j<B.n;j++){
				pc=pc->pre,q=q->pre;
				pc->x+=p->x*q->x;
				pc->pre->x+=pc->x/10;
				pc->x%=10;
			}
		}
		C.back();
		A.destroy(),B.destroy();
		return C;
	}
	friend NUM operator/(NUM a,NUM b){
		NUM A,B,C;
		A.copy(a),B.copy(b);
		node *pc=C.head=new node;
		pc->ne=pc->pre=pc;
		C.sgn=A.sgn*B.sgn;
		B.sgn=A.sgn;//后面有减法 
		A.exp-=B.exp,B.exp=0;
		node *p=A.head->pre;
		for (;A.exp<0;A.exp++) A.n++,insert(p,0),p=p->ne;
		C.exp=A.exp;
		if (A<B) C.n=1;
		else C.n=A.n-B.n+1;
		for (int i=0;i<C.n;i++) insert(pc,0),pc=pc->ne;
		node *q=B.head->pre;
		for (int i=0;i<C.n-1;i++) insert(q,0),q=q->ne,B.n++;
		pc=C.head;
		for (int i=0;i<C.n;i++){
			pc=pc->ne;
			for (;!(A<B);pc->x++) A=A-B;
			if (i<C.n-1) del(B.head->pre),B.n--;
		}
		C.back();
		A.destroy(),B.destroy();
		return C;
	}
}F,G,K;
char opt;
int main(){
	while(1){
		opt=F.get();
		G.get();
		switch(opt){
			case'+':K=F+G;break;
			case'-':K=F-G;break;
			case'*':K=F*G;break;
			case'/':K=F/G;break;
		}
		K.print();
		F.destroy();
		G.destroy();
		K.destroy();
		gc();
	}
}
/*
-101.3/4.2=
89+31=
77-21=
22-112=
22.123+234.32=
1.237*7.231=
-213812.321838*2312.123=
23121933098913.212-823827338497.178=
3123212312.92*-923822131219.23=
101/3=
*/

下面的是几年前的

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=10002,M=1e9;
struct NUM{
    int t;
    ll a[N/9];
    friend void print(NUM x){
        if (!x.t){puts("0");return;}
        printf("%lld",x.a[--x.t]);
        int t[9];
        for (int i=x.t-1;i>=0;i--){
            memset(t,0,sizeof(t));
            for (int j=0;j<9;j++) t[j]=x.a[i]%10,x.a[i]/=10;
            for (int j=8;j>=0;j--) putchar(t[j]|48);
        }
        puts("");
    }
    friend bool operator>(NUM x,NUM y){
        if (x.t!=y.t) return x.t>y.t;
        for (int i=x.t-1;i>=0;i--)
            if (x.a[i]!=y.a[i]) return x.a[i]>y.a[i];
        return 0;
    }
    friend NUM operator+(NUM x,NUM y){
        int i;
        for (i=0;i<x.t || i<y.t || x.a[i];i++){
            if (i+1>=x.t) x.a[i+1]=0;
            if (i<y.t) x.a[i]+=y.a[i];
            if (x.a[i]>=M) x.a[i+1]++,x.a[i]-=M;
        }
        x.t=i;
        return x;
    }
    friend NUM operator-(NUM x,NUM y){
        if (y>x) swap(x,y);
        for (int i=0;i<y.t;i++){
            x.a[i]-=y.a[i];
            if (x.a[i]<0) x.a[i]+=M,x.a[i+1]--;
        }
        while (x.t && !x.a[x.t-1]) x.t--;
        return x;
    }
    friend NUM operator*(NUM x,NUM y){
        NUM z;z.t=x.t+y.t;
        memset(z.a,0,z.t<<3);
        for (int i=0;i<x.t;i++)
            for (int j=0;j<y.t;j++){
                z.a[i+j]+=x.a[i]*y.a[j];
                z.a[i+j+1]+=z.a[i+j]/M;
                z.a[i+j]%=M;
            }
        if (z.t && !z.a[z.t-1]) z.t--;
        return z;
    }
    friend NUM operator*(NUM x,int y){
        int i;
        for (i=0;i<x.t;i++) x.a[i]*=y;
        for (i=0;i<x.t || x.a[i];i++){
            if (i+1>=x.t) x.a[i+1]=0;
            x.a[i+1]+=x.a[i]/M,x.a[i]%=M;
        }
        x.t=i;
        return x;
    }
    friend NUM operator/(NUM x,int y){
        ll k=0;
        for (int i=x.t-1;i>=0;i--){
            k=k*M+x.a[i];
            x.a[i]=k/y;
            k%=y;
        }
        while (x.t && !x.a[x.t-1]) x.t--;
        return x;
    }
    friend NUM div(NUM x,NUM y,bool fl){
        NUM z;z.t=x.t-y.t+1;
        if (z.t<=0){
            z.t=0;
            return fl?z:x;
        }
        memset(z.a,0,z.t<<3);
        for (int i=z.t-1;i>=0;i--){
            for (int j=1<<29;j;j>>=1){
                NUM tmp=y*j;bool fl=tmp.t+i<=x.t;
                if (!fl) continue;
                if (tmp.t+i==x.t){
                    for (int k=tmp.t-1;k>=0;k--)
                        if (x.a[k+i]!=tmp.a[k]){
                            fl=tmp.a[k]<x.a[k+i];
                            break;
                        }
                    if (!fl) continue;
                }
                z.a[i]|=j;
                for (int k=0;k<tmp.t;k++){
                    x.a[k+i]-=tmp.a[k];
                    if (x.a[k+i]<0) x.a[k+i+1]--,x.a[k+i]+=M;
                }
                while (x.t && !x.a[x.t-1]) x.t--;
            }
        }
        while (z.t && !z.a[z.t-1]) z.t--;
        return fl?z:x;
    }
    friend NUM operator/(NUM x,NUM y){return div(x,y,1);}
    friend NUM operator%(NUM x,NUM y){return div(x,y,0);}
    friend NUM gcd(NUM x,NUM y){
        int cnt=0;NUM T;
        while (1){
            if (!x.t || !y.t){
                NUM p,z;
                p.a[0]=2;
                p.t=z.t=z.a[0]=1;
                for (;cnt;cnt>>=1,p=p*p)
                    if (cnt&1) z=z*p;
                if (x.t) return z*x;
                else return z*y;
            }
            bool f1=0,f2=0;
            if (!(x.a[0]&1)) x=x/2,f1=1;
            if (!(y.a[0]&1)) y=y/2,f2=1;
            if (f1 && f2) cnt++;
            if (x>y) x=x-y;
            else T=x,x=y-x,y=T;
        }
    }
}E;
NUM toNUM(char s[]){
    ll f[10];
    f[0]=1;
    for (int i=1;i<10;i++) f[i]=f[i-1]*10;
    NUM A;
    A.t=strlen(s);
    memset(A.a,0,(A.t-1)/9+1<<3);
    for (int i=A.t-1;i>=0;i--) A.a[(A.t-1-i)/9]+=f[(A.t-1-i)%9]*(s[i]^48);
    A.t=(A.t-1)/9+1;
    return A;
}
int main(){
	E.t=E.a[0]=1;
}
蜗角虚名羊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
高精度模板（基础）
Banzed的博客
08-15 1159
高精度计算
Train Problem II hdu 1023
保持饥饿，保持愚昧
07-27 302
Train Problem II hdu1023大数 和 卡特兰数大数模板#include<string> #include<iostream> #include<iosfwd> #include<cmath> #include<cstring> #include<stdlib.h> #include<stdio.h> #include<cstring> #define MAX_L 2005 //最
高精度（模板）
Coco_T的博客
10-05 551
今天写了一道需要高精度的模板题 结果高精乘写错一句，调了1个小时。。。STO 所以写了一遍常用的高精度，在这里再简单说一下高精度的思路：高精加模拟竖式计算 注意每次累加的时候都要加上余数d高精减有一个额外操作：判断两数大小，确定答案符号 第一标准：长度 第二标准每一位数的大小 注意：因为在存贮的时候是倒叙存储，所以在对比的时候也要从高位到低位倒叙对比 模拟竖式计算 借位的时候容易出错
高精模板
风雨兼程
10-06 278
#include<cstdio> #include<cstring> #include<iostream> using namespace std; #define The Bignum of AK #define FOR(i,x,y) for(int i=(x);i<=(y);i++) #define DOR(i,x,y) for(int i=(x);i>=(y);i--) char str[10
C++高精度模板
03-05
支持（无限）高精度加、减、乘、除、模、大于、小于、大于等于、小于等于、位移、等于、不等于、++、--，cin>>，cout 总之，一切int类型的运算都支持
C++高精度模板（加减乘除模）
最新发布
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
高精度模板 c++实现
08-11
高精度c++模板，实测没有问题，可以放心使用，常数一般，代码可移植性和封装性较好
压位高精度模板，支持负数
04-25
自己写的压位高精度支持负数，保证无bug，单精高精运算时不会像其他人一样偷懒直接类型转换再运算，会很慢，可以+-*/%以及快速幂，压位大小可以自己改(不过输出流重载的地方也要改一下)
高精度(模板)
qq_44754132的博客
03-01 281
处理大数运算的时候都是用字符串存的，高级语言一般也都有大数类，分装成一个对象，实际上就是维护了一个字符串，运算就是两个字符串之间的操作，他的运算也有很多啊，毕竟数学运算就有很多，简单的有 大数加大数 大数减大数 大数乘小数 大数除小数 上述几种都是最常见也是最简单的，运算的代码只有几行，而且都是模拟字符串的方法实现。 实际上大小数可以统一起来，就像能用INT的地方用LONG LONG 必然是可...
为什么浮点类型变量不能直接比较？而是用一个范围？
doujianyoutiao的博客
10-24 1244
并不是不可以，而是不推荐，因为容易出错。从下面的例子中能看出（true打印出来是1，false打印出来是0），由于浮点数有精度的问题，数值结果很容易出现偏差。f2 - 81.2不等于0是因为，f2是float类型的，字面量81.2默认是double，所以由于81.2到float类型已经精度不准了，减去精准的81.2得到的结果肯定也不准了。f1/5=f3也是一样的道理，但由于f2和f3都是81.2转过去的，所以这两是相等的，f3跟81.2是不相等。==0也是一样的道理。如果要比较，结合数据类型和自己要求的精度
C++高精度模板实践：高效转换与操作
本文档主要介绍了如何在C++中实现高精度计算，特别是针对整数的高精度模板。作者提供了几个关键函数，如`convert_s`、`convert_b`、`convert_i`、`convert_b(LL)`、`comp`以及`addi`，它们用于处理大整数的表示、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值