A+B again

 

 

题目描述

谷学长有一个非常简单的问题给你,给你两个整数A和B,你的任务是计算A+B。

输入

输入的第一行包含一个整数T(T<=20)表示测试实例的个数,然后2*T行,分别表示A和B两个正整数。注意整数非常大,那意味着你不能用32位整数来处理。你可以确定的是整数的长度不超过1000。

输出

对于每一个样例,你应该输出两行,第一行是"Case #:",#表示第几个样例,第二行是一个等式"A+B=Sum",Sum表示A+B的结果。注意等式中有空格。

样例输入

2

2

112233445566778899 998877665544332211

样例输出

Case 1: 1 + 2 = 3

Case 2: 112233445566778899 + 998877665544332211 = 1111111111111111110

提示

 

大数加法问题,在大数运算里面相对还算简单,不过对初学者博主来说,思路清晰,不过写代码能力明显就有点跟不上了。

下面我们来分析下吧:

     前面的Case什么的只要把相应已知数据输出即可,下面我们重点来分析下加法的结果

    

       首先我们看他的输入,是连续输入,即这个大数字各个位之间是没有空格的,这就意味着用整型的数组难以实现数据的输入问题。因此我们考虑用字符型数组解决输入问题。

       这里方便起见;我们输入字符数组a为“98”,b为“9”  来分析下思路。

       原理就是模拟小学加法,要做加法,首先每位数字应对齐,才可对应相加。因此,我们考虑定义字符数组 char c[1001]来转移并对齐a,b中的元素;

                              cin>>a;  "98"

代码如下:

 
 

 

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

char a[1001],b[1001];

void Add()//字符加法 
{
    
    char c[1001];
    memset(c,'0',1001);
    for(int i=0;i<strlen(a);i++)//对齐 
    {
        c[i]=a[strlen(a)-1-i];
    }
    
    
    memset(a,'0',1001);
    for(int i=0;i<strlen(b);i++)
    {
        a[i]=b[strlen(b)-1-i];
    }
    
    for(int i=0;i<1000;i++)
    {
        a[i]+=c[i]-'0';
        if(a[i]>'9')
        {
            a[i]-=10;
            a[i+1]++; 
        }
    }
    
}


int main()
{
    int T,n=0;
    cin>>T;
    while(T--)
  {
      n++;
    memset(a,'0',1001);
    memset(b,'0',1001);
    
    cin>>a>>b;
    
    cout<<"Case "<<n<<":"<<endl; 
    cout<<a<<" + "<<b<<" = ";
    
    
    Add();
    
    int k;
    for(k=1000;k>=0;k--)//排前导0 
    {
        if(a[k]!='0')
        {break;}
    }
    for(int i=k;i>=0;i--)
    {
        cout<<a[i];
    }
    cout<<endl;
   }
    return 0;
 } 

 

 

 

 

转载于:https://www.cnblogs.com/dearvee/p/5562057.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
B+树是一种常用的数据结构,它可以在磁盘上高效地存储和检索数据。B+树是一种平衡树,它的每个非叶子节点可以有多个子节点,而且每个子节点都存储着一定范围内的关键字。 B+树的特点如下: 1. 所有数据都存储在叶子节点中,非叶子节点只存储索引信息。 2. 叶子节点之间是有序的,并且形成了一个链表,可以支持范围查询和顺序访问。 3. 非叶子节点中的索引信息是有序的,并且可以通过索引信息快速定位到对应的叶子节点。 4. B+树的每个节点都至少包含 t 个关键字,其中 t 是一个常数(通常取值为2-4)。 B+树的插入和删除操作比较复杂,需要进行分裂和合并等操作来保证树的平衡性。下面是B+树的插入和删除过程: 插入操作: 1. 如果树为空,则新建一个叶子节点并插入关键字。 2. 如果插入的位置在叶子节点中,则直接插入关键字,并保持叶子节点有序。 3. 如果插入的位置在非叶子节点中,则递归地将关键字插入到对应的子节点中。 4. 如果插入后导致节点关键字数目超过了 t,则进行分裂操作,并将分裂后的两个节点插入到父节点中。 删除操作: 1. 如果要删除的关键字在叶子节点中,则直接删除,并保持叶子节点有序。 2. 如果要删除的关键字在非叶子节点中: - 如果对应子节点中的关键字数量大于 t,则找到前驱或后继关键字替换,并递归删除替换后的关键字。 - 如果对应子节点中的关键字数量等于 t,则进行合并操作,并递归删除合并后的关键字。 3. 如果删除导致某个节点的关键字数量小于 t/2,则进行合并操作,并将合并后的节点插入到父节点中。 下面是一个简单的B+树实现代码(仅供参考): ```c++ struct Node { bool isLeaf; int numKeys; int keys[MAX_KEYS]; Node* children[MAX_CHILDREN]; Node* next; }; Node* createNode(bool isLeaf) { Node* node = new Node; node->isLeaf = isLeaf; node->numKeys = 0; node->next = NULL; for (int i = 0; i < MAX_KEYS; i++) { node->keys[i] = 0; } for (int i = 0; i < MAX_CHILDREN; i++) { node->children[i] = NULL; } return node; } Node* search(Node* node, int key) { if (node == NULL) { return NULL; } int i = 0; while (i < node->numKeys && key > node->keys[i]) { i++; } if (node->isLeaf && i < node->numKeys && key == node->keys[i]) { return node; } return search(node->children[i], key); } void split(Node* parent, int pos, Node* child) { Node* newChild = createNode(child->isLeaf); newChild->numKeys = MAX_KEYS / 2; for (int i = 0; i < newChild->numKeys; i++) { newChild->keys[i] = child->keys[i + MAX_KEYS / 2]; } if (!child->isLeaf) { for (int i = 0; i < MAX_CHILDREN / 2; i++) { newChild->children[i] = child->children[i + MAX_CHILDREN / 2]; } } child->numKeys = MAX_KEYS / 2; for (int i = parent->numKeys; i > pos; i--) { parent->children[i + 1] = parent->children[i]; parent->keys[i] = parent->keys[i - 1]; } parent->children[pos + 1] = newChild; parent->keys[pos] = newChild->keys; parent->numKeys++; } void insert(Node*& root, int key) { if (root == NULL) { root = createNode(true); root->keys = key; root->numKeys++; return; } Node* node = root; Node* parent = NULL; int pos = -1; while (!node->isLeaf) { parent = node; pos = -1; for (int i = 0; i < node->numKeys; i++) { if (key >= node->keys[i]) { pos = i; } else { break; } } if (pos == -1) { node = node->children; } else { node = node->children[pos + 1]; } } pos = -1; for (int i = 0; i < node->numKeys; i++) { if (key == node->keys[i]) { return; } else if (key > node->keys[i]) { pos = i; } else { break; } } for (int i = node->numKeys; i > pos + 1; i--) { node->keys[i] = node->keys[i - 1]; } node->keys[pos + 1] = key; node->numKeys++; if (node->numKeys == MAX_KEYS) { if (parent == NULL) { parent = createNode(false); root = parent; parent->children = node; } split(parent, pos, node); } } void merge(Node* parent, int pos, Node* left, Node* right) { left->keys[left->numKeys++] = parent->keys[pos]; for (int i = 0; i < right->numKeys; i++) { left->keys[left->numKeys++] = right->keys[i]; } if (!left->isLeaf) { for (int i = 0; i < right->numKeys; i++) { left->children[left->numKeys + i] = right->children[i]; } } left->next = right->next; delete right; for (int i = pos; i < parent->numKeys - 1; i++) { parent->children[i + 1] = parent->children[i + 2]; parent->keys[i] = parent->keys[i + 1]; } parent->numKeys--; } void remove(Node*& root, int key) { if (root == NULL) { return; } Node* node = root; Node* parent = NULL; int pos = -1; while (!node->isLeaf) { parent = node; pos = -1; for (int i = 0; i < node->numKeys; i++) { if (key >= node->keys[i]) { pos = i; } else { break; } } if (pos == -1) { node = node->children; } else { node = node->children[pos + 1]; } } pos = -1; for (int i = 0; i < node->numKeys; i++) { if (key == node->keys[i]) { pos = i; break; } } if (pos == -1) { return; } for (int i = pos; i < node->numKeys - 1; i++) { node->keys[i] = node->keys[i + 1]; } node->numKeys--; if (node == root) { // root is a leaf return; } while (node != root && node != NULL && node->numKeys < MAX_KEYS / 2) { int leftPos = -1, rightPos = -1; for (int i = 0; i <= parent->numKeys; i++) { if (parent->children[i] == node) { leftPos = i - 1; rightPos = i + 1; break; } } Node *leftChild, *rightChild; bool flagLeftOverFlow, flagRightOverFlow; if (leftPos >= 0) { // has left sibling leftChild = parent->children[leftPos]; flagLeftOverFlow = leftChild != NULL && leftChild != NULL && leftChild->numKeys > MAX_KEYS / 2; // whether left sibling can // afford one key if (!flagLeftOverFlow && leftPos >= 0 && rightPos <= parent->numKeys) { // merge with left sibling merge(parent, leftPos, leftChild, node); node = leftChild; // after merge, the current position is the new merged child continue; } } else { // no left sibling flagLeftOverFlow = false; // this flag is set to false to ensure that it will not trigger merge operation with left sibling later leftChild = NULL; // leftChild is set to NULL to avoid using it later } if (rightPos <= parent->numKeys) { // has right sibling rightChild = parent ->children[rightPos]; // after merge operation with left sibling, right sibling could have been moved to the current position // therefore, rightPos should be calculated again flagRightOverFlow = rightChild != NULL && rightChild != NULL && rightChild ->numKeys > MAX_KEYS / 2; // whether right sibling can afford one key if (!flagRightOverFlow && leftPos >= 0 && rightPos <= parent->numKeys) { // merge with right sibling merge(parent, leftPos, node, rightChild); node = leftChild; // after merge, the current position is the new merged child continue; } } else { // no right sibling flagRightOverFlow = false; // this flag is set to false to ensure that it will not trigger merge operation with right sibling later rightChild = NULL; // rightChild is set to NULL to avoid using it later } if (flagLeftOverFlow || flagRightOverFlow) { // borrow from sibling and update parent's keys if (flagLeftOverFlow && (!flagRightOverFlow || leftChild ->numKeys > rightChild ->numKeys)) { // prefer borrowing from left sibling for (int i = node ->numKeys - 1; // move current keys to make room for borrowed key from sibling i >= 0; --i) { node ->keys[i + 1] = node ->keys[i]; } if (!node ->isLeaf) { // move children accordingly for non-leaf nodes for (int i = node-> numKeys - 1; i >= 0; --i) { node ->children[i + 2] = node-> children[i + 1]; } node ->children = leftChild-> children[leftChild-> numKeys + 1]; ++node-> numKeys; leftChild-> children[leftChild-> numKeys + 1] = NULL; --leftChild-> numKeys; parent-> keys[leftPos] = leftChild-> keys[leftChild-> numKeys - 1]; leftChild-> keys[leftChild-> numKeys - 1] = 0; continue; } else { // leaf nodes need to update next pointer as well ++node-> numKeys; int newKeyIndex = --leftChild-> numKeys; parent-> keys[leftPos] = leftChild-> keys[newKeyIndex]; ++node-> numKeys; node ->next = leftChild-> next; leftChild-> next = node; continue; } } else { // borrow from right sibling or its children if (!node-> isLeaf) { // move children accordingly for non-leaf nodes ++node-> numKeys; int newKeyIndex = ++node-> numKeys; if (newKeyIndex >= MAX_KEYS) newKeyIndex--; node ->children[newKeyIndex + 1] = rightChild-> children; parent-> keys[rightPos - 1] = rightChild-> keys; ++rightChild-> numKeys; for (int k = 0; k < rightChild-> numKeys - 1; ++k) rightChild-> keys[k] = rightChild-> keys[k + 1]; for (int k = 0; k < rightChild-> numKeys + 1; ++k) rightChild-> children[k] = rightChild-> children[k + 1]; --rightChild-> numKeys; continue; } else { // leaf nodes need to update next pointer as well ++node-> numKeys; int newKeyIndex = ++node-> numKeys; if (newKeyIndex >= MAX_KEYS) newKeyIndex--; node ->keys[newKeyIndex - 1] = rightChild-> keys; ++rightChild-> numKeys; for (int k = 0; k < rightChild-> numKeys - 1; ++k) rightChild-> keys[k] = rightChild-> keys[k + 1]; --rightChild-> numKeys; parent-> keys[rightPos - 1] = rightChild-> keys; continue; } } } break; } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值