【C++/string】 大数高精度运算模板

大数高精度运算模板

暂不考虑输入存在负数的情况 / 待补充

1.1 A+B Problem 加法

#include <iostream>
#include <algorithm>
using namespace std;

string add(string a, string b){
    string ans;
    /* 翻转两个数字字符串,使得后面的for循环从个位开始相加 */
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    /* 初次补0,保证最高位都是‘0’ */
    a.push_back('0');
    b.push_back('0');
    if(a.size() < b.size()) swap(a, b);
    /* 短的字符串高位补‘0’,使两字符串位数相等 */
    while(b.size() < a.size()) b.push_back('0');
    /* 数组c:存放每位相加后的结果  k:字符串补‘0’后的位数 */
    int c[1000]={0}, k = a.size();
    /* 从个位开始,模拟加法 */
    for(int i = 0; i < a.size(); i++){
        int sum = c[i] + a[i]-'0' + b[i] - '0';
        c[i] = sum%10;
        c[i+1] += sum/10;
    }
    /* 去除高位零 */
    while(c[k]==0 && k>=0) k--;
    /* 输出 */
    while(k >= 0)
        ans.push_back(c[k--]+'0');
    return ans;
}

int main(){
    string a, b;
    cin >> a >> b;
    /* 数组c设置大小为1000,答案的最大精度为1000位 */
    cout << add(a, b);
    return 0;
}

1.2 A-B Problem 减法

#include <iostream>
#include <algorithm>
using namespace std;

string sub(string a, string b){
    string ans;
    /* flag:true表示被减数小于减数,结果为负。false表示结果为正 */
    bool flag = false;
    /* 首先判断被减数与减数的大小关系 */
    if(a.size() < b.size() || (a.size()==b.size() && a < b)){
        swap(a, b);
        flag = true;    
    }
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    /* 初次补0,保证最高位都是‘0’ */
    a.push_back('0');  b.push_back('0');
    if(a.size() < b.size()) swap(a, b);
    /* 短的字符串高位补‘0’,使两字符串位数相等 */
    while(b.size() < a.size()) b.push_back('0');
    int c[1000]={0}, k = a.size();
    /* 从个位开始,模拟减法 */
    for(int i = 0; i < a.size(); i++){
        if(a[i] < b[i]) a[i]+=10, a[i+1]--;
        c[i] = a[i] - b[i];
    }
    /* 去除高位‘0’ */
    while(c[k]==0 && k>=0) k--;
    /* 输出 */
    if(flag) ans.push_back('-');
    while(k >= 0)
        ans.push_back(c[k--]+'0');
    return ans;
}

int main(){
	/* tips:取消cin与stdin的同步,加快cin读取数据的速度。 */
    ios::sync_with_stdio(false);
    string a, b;
    cin >> a >> b;
    cout << sub(a,b);
    return 0;
}

1.3 A*B Problem 乘法

#include <iostream>
#include <algorithm>
using namespace std;

string mcl(string a, string b){
    string ans;
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    /* k:ans字符串可能的最大位数 */
    int c[1000]={0}, k = a.size()+b.size()+1;
    /* 从个位开始,模拟乘法:a的每一位乘以b的每一位 */
    for(int i = 0; i < a.size(); i++)
        for(int j = 0; j < b.size(); j++){
            c[i+j] += (a[i]-'0')*(b[j]-'0');  /* c[i+j]暂存初步乘的结果 */
            c[i+j+1] += c[i+j]/10;   /* 进位 */
            c[i+j] %= 10;       /* c[i+j]保留个位 */
        }
    /* 去除高位‘0’ */
    while(c[k]==0 && k>=0) k--;
    /* 输出 */
    while(k >= 0)
        ans.push_back(c[k--]+'0');
    return ans;
}

int main(){
    ios::sync_with_stdio(false);
    string a, b;
    cin >> a >> b;
    cout << mcl(a,b);
    return 0;
}

1.4 A/B Problem 高精度/低精度 除法

A:高精度数 / 采用string类型读取
B:低精度数 / 采用long long类型读取

#include <iostream>
using namespace std;

string div(string a, long long b){
	string ans;
	/* rest:存储余数 */
    int c[256] = {0}, rest = 0;
    /* 从最高位开始,模拟除法 */
    for(int i = 0; i < a.size(); i++){
        rest = 10*rest + a[i] - '0';
        c[i] = rest / b;
        rest %= b;
    }
    // 处理计算结果
    int k = 0;
    /* 去除高位‘0’,k最大不能超过a.size()-1,因为商最少也会有1位 */
    while(c[k] == 0 && k < a.size()-1)
        k++;
    for(int i = k; i < a.size(); i++)
        ans.push_back(c[i]+'0');
    return ans;
}       

int main(){
    string a;
    long long b;
    cin >> a >> b;
    cout << div(a, b);
    return 0;
}

END

  • 3
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实现高精度运算的双向循环链表可以分为三个部分:节点结构体、链表结构体和高精度运算函数。 首先是节点结构体,可以定义如下: ```c++ struct Node { int val; // 当前节点的值 Node* next; // 指向下一个节点的指针 Node* prev; // 指向上一个节点的指针 // 构造函数 Node(int v = 0, Node* n = nullptr, Node* p = nullptr) : val(v), next(n), prev(p) {} }; ``` 接下来是链表结构体,可以定义如下: ```c++ struct LinkedList { Node* head; // 头指针 Node* tail; // 尾指针 // 构造函数 LinkedList() : head(nullptr), tail(nullptr) {} // 复制构造函数 LinkedList(const LinkedList& lst) { head = tail = nullptr; Node* p = lst.head; while (p != nullptr) { push_back(p->val); p = p->next; } } // 析构函数 ~LinkedList() { while (head != nullptr) { Node* p = head; head = head->next; delete p; } } // 在链表尾部插入一个节点 void push_back(int v) { Node* p = new Node(v, nullptr, tail); if (tail != nullptr) { tail->next = p; } else { head = p; } tail = p; } // 在链表头部插入一个节点 void push_front(int v) { Node* p = new Node(v, head, nullptr); if (head != nullptr) { head->prev = p; } else { tail = p; } head = p; } }; ``` 最后是高精度运算函数,可以实现加法、减法和乘法等运算: ```c++ // 高精度加法 LinkedList add(const LinkedList& a, const LinkedList& b) { LinkedList res; int carry = 0; // 进位 Node* p = a.tail; Node* q = b.tail; while (p != nullptr || q != nullptr) { int x = (p != nullptr) ? p->val : 0; int y = (q != nullptr) ? q->val : 0; int sum = x + y + carry; res.push_front(sum % 10); carry = sum / 10; if (p != nullptr) { p = p->prev; } if (q != nullptr) { q = q->prev; } } if (carry > 0) { res.push_front(carry); } return res; } // 高精度减法 LinkedList sub(const LinkedList& a, const LinkedList& b) { LinkedList res; int borrow = 0; // 借位 Node* p = a.tail; Node* q = b.tail; while (p != nullptr || q != nullptr) { int x = (p != nullptr) ? p->val : 0; int y = (q != nullptr) ? q->val : 0; int diff = x - y - borrow; if (diff < 0) { diff += 10; borrow = 1; } else { borrow = 0; } res.push_front(diff); if (p != nullptr) { p = p->prev; } if (q != nullptr) { q = q->prev; } } // 去除前导零 while (res.head->next != nullptr && res.head->val == 0) { Node* p = res.head; res.head = res.head->next; res.head->prev = nullptr; delete p; } return res; } // 高精度乘法 LinkedList mul(const LinkedList& a, const LinkedList& b) { LinkedList res; int n = a.tail != nullptr ? 1 : 0; int m = b.tail != nullptr ? 1 : 0; if (n == 0 || m == 0) { return res; } int len = n + m - 1; int* c = new int[len]; memset(c, 0, len * sizeof(int)); Node* p = a.tail; for (int i = 0; p != nullptr; i++, p = p->prev) { Node* q = b.tail; for (int j = 0; q != nullptr; j++, q = q->prev) { c[i + j] += p->val * q->val; c[i + j + 1] += c[i + j] / 10; c[i + j] %= 10; } } while (len > 0 && c[len - 1] == 0) { len--; } for (int i = len - 1; i >= 0; i--) { res.push_back(c[i]); } delete[] c; return res; } ``` 这样,我们就实现了一个可以进行高精度运算的双向循环链表。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值