AI 助理
备案控制台
开发者社区 人工智能 文章 正文

[算法题] 大数减法运算

2014-06-16 733
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： //test.h #ifndef _TEST_H #define _TEST_H #include #define MAXSIZE 50 struct DoubleList { int sqlist[MAXSIZE]; int key; ...

 

//test.h

#ifndef _TEST_H
#define _TEST_H
#include <stdlib.h>

#define MAXSIZE 50

struct DoubleList
{ 
    int sqlist[MAXSIZE];
    int key;
    int size;
    int data;
} DLIST_S;

typedef struct Node
{
    int data;
    struct Node *plast;
    struct Node *pnext;
} DNODE_S;


#if 1   /* 双链表相关操作 */
/*****************************************************************************
Description   : 遍历打印链表的所有节点
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void PrintNode(DNODE_S **ppLinkList);

/*****************************************************************************
Description   : 创建双链表，并把第一个节点的数值初始化为data
Input Param   : 
Output Param  : 无
Return Value  : 成功返回0，失败返回-1
*****************************************************************************/
int CreateDoubleLinkList(DNODE_S **ppLinkList, int data);

/*获取链表中节点个数*/
/*****************************************************************************
Description   : 获取链表中节点个数
Input Param   : 
Output Param  : 无
Return Value  : 返回节点个数
*****************************************************************************/
int GetListLength(DNODE_S **ppLinkList);

/*****************************************************************************
Description   : 初始化一个新结点
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void InitNewNode(DNODE_S **ppNewNode, int data);

/*****************************************************************************
Description   : 获取链表中的最后一个节点
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void GetLastNode(DNODE_S **ppLinkList, DNODE_S **pLastNode);

/*****************************************************************************
Description   : 在链表第pos个位置插入数据等于data的节点
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void InsertNode(DNODE_S **ppLinkList, int pos, int data);

/*****************************************************************************
Description   : 删除链表中第pos个节点
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void MoveNode(DNODE_S **ppLinkList, int pos);
#endif

#if 1   /* 数组和链表转换 */
/*****************************************************************************
Description   : 将数组写入链表中，链表中的数据的先后顺序和数组中的顺序要保持一致 
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void IntToList(DNODE_S **ppLinkList, int *paiArray, int size);

/*****************************************************************************
Description   : 将链表写入数组中，数组中的数据的先后顺序和链表中的顺序要保持一致 
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void ListToInt(DNODE_S *pLinkList, int *paiArray);

/*****************************************************************************
Description   : 将字符数组写入链表中，链表中的数据的先后顺序和数组中的顺序要保持一致 
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void StringToList(DNODE_S **ppLinkList, const char *pcString);

/*****************************************************************************
Description   : 将链表写入字符数组中，数组中的数据的先后顺序和链表中的顺序要保持一致 
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
void ListToString(DNODE_S *pLinkList, char *pcString); 
#endif

#if 1
/*****************************************************************************
Description   : 获取小数的位数，如果是整数返回0
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
int GetDecimalLength(const char *pcNum);

/*****************************************************************************
Description   : 判断字符是否为合法数字
Input Param   : 
Output Param  : 无
Return Value  : 
*****************************************************************************/
bool IsValidNum(char c);
#endif
#endif

 

//test.cpp

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include "test.h"
using namespace std;

#define ERR -1
#define OK  0
#define TEST 1
#define POSITIVE_NUMBER 0
#define NEGATIVE_NUMBER 1

#if 1
void PrintNode(DNODE_S **ppLinkList)
{
    DNODE_S *node = *ppLinkList;
    printf("\r\n");
    printf("%d ", node->data);
    while (node->pnext != NULL)
    {
        node = node->pnext;
        printf("%d ", node->data);
    }
}

int CreateDoubleLinkList(DNODE_S **ppLinkList, int data)  
{
    DNODE_S *pHeadNode;

    pHeadNode = (DNODE_S *)malloc(sizeof(DNODE_S));
    if (NULL == pHeadNode)
    {
        return ERR;
    }
    pHeadNode->data = data;
    pHeadNode->plast = NULL;
    pHeadNode->pnext = NULL;

    *ppLinkList = pHeadNode;

    return OK;
}

int GetListLength(DNODE_S **ppLinkList)
{
    int count = 1;
    DNODE_S *node = *ppLinkList;
    if (NULL == node)
    {
        return 0;
    }

    while (node->pnext != NULL)
    {
        node = node->pnext;
        count++;
    }
    
    return count;
}

void GetLastNode(DNODE_S **ppLinkList, DNODE_S **pLastNode)
{
    DNODE_S *pTmpNode = *ppLinkList;
    *pLastNode = NULL;
    while (pTmpNode->pnext != NULL)
    {
        pTmpNode = pTmpNode->pnext;
    }
    *pLastNode = pTmpNode;
}

void InitNewNode(DNODE_S **ppNewNode, int data)
{    
    DNODE_S *pNewNode    = NULL;
    /* 初始化新结点 */
    pNewNode = (DNODE_S *)malloc(sizeof(DNODE_S));
    if (NULL == pNewNode)
    {
        return;
    }
    pNewNode->data = data;
    pNewNode->plast = NULL;
    pNewNode->pnext = NULL;
    *ppNewNode = pNewNode;
}

void InsertNode(DNODE_S **ppLinkList, int pos, int data)
{
    int index = 1;
    int iNodeNum = GetListLength(ppLinkList);
    DNODE_S *pPrevNode = *ppLinkList;
    DNODE_S *pNextNode = NULL;
    DNODE_S *pNewNode    = NULL;

    if (pos > iNodeNum || pos < 0)
    {
        return;
    }

    /* 初始化新结点 */
    InitNewNode(&pNewNode, data);

    /* 1、插入头部 */
    if (0 == pos)
    {
        pPrevNode->plast = pNewNode;
        pNewNode->pnext = pPrevNode;
        *ppLinkList = pNewNode;
        return;
    }

    /* 找到插入位置 */
    while (index != pos)
    {
        pPrevNode = pPrevNode->pnext;
        index++;
    }
    pNextNode = pPrevNode->pnext;    
    
    /* 2、插入尾部 */
    if (iNodeNum == pos)
    {
        pPrevNode->pnext = pNewNode;
        pNewNode->plast  = pPrevNode;
        return;
    }

    /* 3、插入中间位置 */
    pNewNode->pnext        = pNextNode;
    pNewNode->plast        = pPrevNode;
    pPrevNode->pnext    = pNewNode;
    pNextNode->plast    = pNewNode;

}

void MoveNode(DNODE_S **ppLinkList, int pos)
{
    DNODE_S *node = *ppLinkList;
    DNODE_S *pPrevNode = NULL;
    DNODE_S *pNextNode = NULL;

    while(pos--)
    {
        node = node->pnext;
    }

    pPrevNode = node->plast;
    pNextNode = node->pnext;
    pPrevNode->pnext = pNextNode;
    pNextNode->plast = pPrevNode;

    free(node);
}

#endif

#if 1    /* 数组和链表转换 */
void IntToList(DNODE_S **ppLinkList, int *paiArray, int size)  
{
    int j = 0;
    int data = 0;
    DNODE_S *s = *ppLinkList;

    s->data = *(paiArray + (size-1));

    for(j = 2; j < (size+1); j++)
    {
        data = *(paiArray + (size-j));
        InsertNode(ppLinkList, 0, data);
    }

    return;
}

void ListToInt(DNODE_S *pLinkList, int *paiArray)
{
    int j = 0;
    DNODE_S *s = pLinkList;

    while(s != NULL)
    {
        *(paiArray + j) = s->data;
        s = s->pnext;
        j++;
    }

    return;
}

bool IsValidNum(char c)
{
    if ('0' <= c && c <= '9')
    {
        return true;
    }
    return false;
}

void StringToList(DNODE_S **ppLinkList, const char *pcString)  
{
    int i = 0;
    int j = 0;
    int data = 0;
    int len = (int)strlen(pcString);
    DNODE_S *s = *ppLinkList;

    s->data = pcString[0] - '0';
    
    for(i = 1, j = 1; i < len; i++)
    {
        if (IsValidNum(pcString[i]))
        {
            data = pcString[i] - '0';
            InsertNode(ppLinkList, j, data);
            j++;
        }
    }
    return;
}

void ListToString(DNODE_S *pLinkList, char *pcString)  
{
    int j = 0;
    DNODE_S *s = pLinkList;

    while(s != NULL)
    {
        *(pcString + j) = s->data + '0';
        s = s->pnext;
        j++;
    }

    return;
}
#endif
#if 1
int CompareNum(char *pcNumA, char *pcNumB)
{
    int lenA = (int)strlen(pcNumA);
    int lenB = (int)strlen(pcNumB);

    if (lenA > lenB)
    {
        return 1;
    }
    else if (lenA < lenB)
    {
        return -1;
    }
    else
    {
        return strcmp(pcNumA, pcNumB);
    }
}

int GetDecimalLength(const char *pcNum)
{
    int i = 0;
    int len = (int)strlen(pcNum);
    while (pcNum[i] != '\0' && pcNum[i] != '.')
    {
        i++;
    }
    if (i == len)
    {
        return 0;
    }
    return len - i - 1;
}

char* EnlargeNum(const char *pcNum, int size)
{
    int i = 0, j = 0, k = 0;
    char pcTemp[1024] = {0};
    int iDecimalLen = GetDecimalLength(pcNum);
    char *pcResult = NULL;

    if (iDecimalLen > size)
    {
        return NULL;
    }
    
    /* 如果是整数，则直接在末尾补上size个'0' */
    if (0 == iDecimalLen)
    {
        memcpy(pcTemp, pcNum, strlen(pcNum));
        memset(pcTemp + strlen(pcNum), '0', size);
        pcResult = (char*) malloc (strlen(pcNum)+size+1);
        memset(pcResult, 0, strlen(pcNum)+size+1);
        memcpy(pcResult, pcTemp, strlen(pcTemp));

        return pcResult;
    }
    /* 如果是小数, 先偏移小数点，如果不够，末尾补'0' */
    while (pcNum[i] != '\0')
    {
        if (pcNum[i] == '.')
        {
            i++;
            k = 0;
            continue;
        }

        pcTemp[j] = pcNum[i];
        i++;
        j++;
        k++;
    }
    memset(pcTemp + j, '0', size - k); 

    /* 如果数字以'0'开头，要去除 */    
    if(pcTemp[0] == '0')
    {
        pcResult = (char*) malloc (strlen(pcTemp));
        memset(pcResult, 0, strlen(pcTemp));
        memcpy(pcResult, pcTemp + 1, strlen(pcTemp)-1);
    }
    else      
    {
        pcResult = (char*) malloc (strlen(pcTemp)+1);
        memset(pcResult, 0, strlen(pcTemp)+1);
        memcpy(pcResult, pcTemp, strlen(pcTemp));
    }
    return pcResult;
}

#endif

#if 1
void OperatePlus(int numA, int numB, int &result, int &carry)
{
    result = numA + numB + carry;
    carry = result / 10;
    result = result % 10;
}

void ExceedPlusAlgorithm(DNODE_S **ppResult, DNODE_S *pLastNode, int carry)
{
    int sum = 0;

    while (pLastNode->plast != NULL)
    {
        pLastNode = pLastNode->plast;
        OperatePlus(pLastNode->data, 0, sum, carry);
        InsertNode(ppResult, 0, sum);           
    }
    if (0 != carry)
    {
        InsertNode(ppResult, 0, carry);  
    }
    return;
}

void BigIntegerPlus(DNODE_S **ppResult, DNODE_S **ppNumA, DNODE_S **ppNumB)
{
    int sum        = 0;
    int carry    = 0;    
    int iLenOfA = 0;
    int iLenOfB = 0;
    DNODE_S *pLastNodeOfA    = NULL;
    DNODE_S *pLastNodeOfB    = NULL;
    DNODE_S *pNewNode        = NULL;

    if (NULL == ppNumA || NULL == ppNumB)
    {
        return;
    }

    iLenOfA = GetListLength(ppNumA);
    iLenOfB = GetListLength(ppNumB);
    if (0 == iLenOfA)
    {
        ppResult = ppNumB;
        return;
    }
    if (0 == iLenOfB)
    {
        ppResult = ppNumA;
        return;
    }
    
    GetLastNode(ppNumA, &pLastNodeOfA);
    GetLastNode(ppNumB, &pLastNodeOfB);

    /* 1、从两个数组最末位开始向前扫描，把对应的位数相加，有进位则加入前一位中 */
    OperatePlus(pLastNodeOfA->data, pLastNodeOfB->data, sum, carry);
    CreateDoubleLinkList(ppResult, sum);
    while (pLastNodeOfA->plast != NULL && pLastNodeOfB->plast != NULL)
    {
        pLastNodeOfA = pLastNodeOfA->plast;
        pLastNodeOfB = pLastNodeOfB->plast;
        OperatePlus(pLastNodeOfA->data, pLastNodeOfB->data, sum, carry);
        InitNewNode(&pNewNode, sum);
        InsertNode(ppResult, 0, sum);        
    }
   
    /* 2、如果P/Q两个数组数字一样多，则判断是否有进位 */
    if (pLastNodeOfA->plast == NULL && pLastNodeOfB->plast == NULL)
    {
        if (0 != carry)
        {
            InsertNode(ppResult, 0, carry);  
        }
        return;
    }

    /* 3、把没有扫描完的数组里的数字全部加入plus数组 */
    if (pLastNodeOfB->plast != NULL)
    {
        ExceedPlusAlgorithm(ppResult, pLastNodeOfB, carry);
        return;
    }
    
    if (pLastNodeOfA->plast != NULL)
    {
        ExceedPlusAlgorithm(ppResult, pLastNodeOfA, carry);
        return;
    }
}
#endif
#if 1
void OperateSub(int numA, int numB, int &result, int &carry)
{
    if (numA + carry >= numB)
    {

        result = numA + carry - numB ;
        carry = 0;
    }
    else
    {
        result = numA + carry + 10 - numB ;
        carry = -1;
    }
}

void ExceedSubAlgorithm(DNODE_S **ppResult, DNODE_S *pLastNode, int carry)
{
    int sum = 0;

    while (pLastNode->plast != NULL)
    {
        pLastNode = pLastNode->plast;
        OperateSub(pLastNode->data, 0, sum, carry);
        InsertNode(ppResult, 0, sum);           
    }
    if (0 != carry)
    {
        InsertNode(ppResult, 0, carry);  
    }
    return;
}




void BigIntegerSub(DNODE_S **ppResult, DNODE_S **ppNumA, DNODE_S **ppNumB)
{
    int sum        = 0;
    int carry    = 0;    
    int iLenOfA = 0;
    int iLenOfB = 0;
    DNODE_S *pLastNodeOfA    = NULL;
    DNODE_S *pLastNodeOfB    = NULL;
    DNODE_S *pNewNode        = NULL;

    if (NULL == ppNumA || NULL == ppNumB)
    {
        return;
    }

    iLenOfA = GetListLength(ppNumA);
    iLenOfB = GetListLength(ppNumB);
    if (0 == iLenOfA)
    {
        ppResult = ppNumB;
        return;
    }
    if (0 == iLenOfB)
    {
        ppResult = ppNumA;
        return;
    }
    
    GetLastNode(ppNumA, &pLastNodeOfA);
    GetLastNode(ppNumB, &pLastNodeOfB);

    /* 1、从两个数组最末位开始向前扫描，把对应的位数相加，有进位则加入前一位中 */
    OperateSub(pLastNodeOfA->data, pLastNodeOfB->data, sum, carry);
    CreateDoubleLinkList(ppResult, sum);
    while (pLastNodeOfA->plast != NULL && pLastNodeOfB->plast != NULL)
    {
        pLastNodeOfA = pLastNodeOfA->plast;
        pLastNodeOfB = pLastNodeOfB->plast;
        OperateSub(pLastNodeOfA->data, pLastNodeOfB->data, sum, carry);
        InitNewNode(&pNewNode, sum);
        InsertNode(ppResult, 0, sum);        
    }

    /* 2、如果P/Q两个数组数字一样多，则判断是否有进位 */
    if (pLastNodeOfA->plast == NULL && pLastNodeOfB->plast == NULL)
    {
        if (0 != carry)
        {
            InsertNode(ppResult, 0, carry);  
        }
        return;
    }

    /* 3、把没有扫描完的数组里的数字全部加入plus数组 */
    if (pLastNodeOfA->plast != NULL)
    {
        ExceedSubAlgorithm(ppResult, pLastNodeOfA, carry);
        return;
    }
   
    return;

}

char* FromatOutpuString(DNODE_S *pstResult, int iMaxDecimal, int flag)
{
    int i        = 0;
    int j        = 0;
    int size    = 0;
    
    char *pcResult    = NULL;
    char *pcResultCopy = NULL;
    
    /* 分配内存，要考虑正负号、小数点和末尾'\0'，所以分配大小为size+3 */
    size = GetListLength(&pstResult);
    pcResult = (char*)malloc(size+3);
    memset(pcResult, 0, size+3);
    pcResultCopy = (char*)malloc(size+3);
    
    memset(pcResultCopy, 0, size+3);
    ListToString(pstResult, pcResult);

    /* 去除计算结果前面多余的0，如0345，改为345 */
    while (pcResult[i] != '\0')
    {
        if (pcResult[i] != '0')
        {
            break;
        }
        i++;
        size--;
    }
    memcpy(pcResultCopy, pcResult + i, strlen(pcResult)-i+1);
    memset(pcResult, 0, size+3);
    printf("\r\n 去除前面的0: pcResultCopy = %s", pcResultCopy);

    i = 0;
    j = 0;
    /* 设置正负号 */
    if (1 == flag)
    {
        pcResult[j++] = '-';
    }
    if (iMaxDecimal > 0)
    {
        /* 原操作数有小数，需要还原小数点 */
        while (i < size - iMaxDecimal)
        {
            pcResult[j++] = pcResultCopy[i++];
        }
        memset(pcResult + j, '.', 1);
        memcpy(pcResult + j + 1, pcResultCopy + i, iMaxDecimal);
    }
    else
    {
        /* 若没有小数，直接把结果拷贝给pcResult */
        memcpy(pcResult + j, pcResultCopy, size);
    }
    printf("\r\n 尚未去除尾部的0: pcResultCopy = %s, iMaxDecimal = %d", pcResult
, iMaxDecimal);
    
    /* 消除尾部的0 */
    i = (int)strlen(pcResult) - 1;
    while (i >= 0)
    {
        if (pcResult[i] == '0')
        {
            pcResult[i] = '\0';
        }
        else if (pcResult[i] == '.')
        {
            pcResult[i] = '\0';
            break;
        }
        else
        {
            break;
        }
        i--;
    }
    return pcResult;
}


void BigNumSub(const char *pcMinuend, const char *pcSubtrahend, char **
ppcResult)
{
    int i = 0;
    int j = 0;
    int flag             = 0;
    int compare            = 0;
    int iLenDecimalA    = 0;
    int iLenDecimalB    = 0;
    int iMaxDecimal        = 0;
    DNODE_S *pstNumA    = NULL;
    DNODE_S *pstNumB    = NULL;
    DNODE_S *pstResult    = NULL;

    char *pcTemp = NULL;
    char *pcMinuendEnlarge = NULL;
    char *pcSubtrahendEnlarge = NULL;
    char *pcFinalResult = NULL;

    /* 获取最长小数位数 */
    iLenDecimalA = GetDecimalLength(pcMinuend);
    iLenDecimalB = GetDecimalLength(pcSubtrahend);
    iMaxDecimal = (iLenDecimalA > iLenDecimalB) ? iLenDecimalA : iLenDecimalB;

    /* 按最长小数位数放大两个操作数 */
    pcMinuendEnlarge    = EnlargeNum(pcMinuend,iMaxDecimal);
    pcSubtrahendEnlarge    = EnlargeNum(pcSubtrahend, iMaxDecimal);

    /* 比较数字大小 */
    compare = CompareNum(pcMinuendEnlarge, pcSubtrahendEnlarge);
    if (compare < 0)    /* 被减数小于减数，则交换数字字符串，并把正负标志位置为1 
*/
    {
        pcTemp = pcMinuendEnlarge;
        pcMinuendEnlarge = pcSubtrahendEnlarge;
        pcSubtrahendEnlarge = pcTemp;
        flag = NEGATIVE_NUMBER;
    }
    if (compare == 0)    /* 两数相等，则直接返回结果为0的字符串 */
    {
        pcFinalResult = (char*)malloc(2);
        memset(pcFinalResult, 0, 2);
        pcFinalResult[0] = '0';
        *ppcResult = pcFinalResult;
        return;
    }
#if TEST    
    printf("\r\n ============== Change Num ==============");
    printf("\r\n pcMinuendEnlarge = %s", pcMinuendEnlarge);
    printf("\r\n pcSubtrahendEnlarge = %s", pcSubtrahendEnlarge);
#endif    
    /* 把放大后的两个整数字符串放入链表，然后逐位相减 */
    CreateDoubleLinkList(&pstNumA, 0);
    CreateDoubleLinkList(&pstNumB, 0);
    CreateDoubleLinkList(&pstResult, 0);
    StringToList(&pstNumA, pcMinuendEnlarge);
    StringToList(&pstNumB, pcSubtrahendEnlarge);   
    BigIntegerSub(&pstResult, &pstNumA, &pstNumB);

    /* 恢复小数点，并去除整数前的0和小数尾部的0 */
    pcFinalResult = FromatOutpuString(pstResult, iMaxDecimal, flag);
  
    *ppcResult = pcFinalResult;
    free(pstNumA);
    free(pstNumB);
    free(pstResult);
}
#endif



/*****************************************************************************
Description  : 两个任意长度的正数相减
Prototype    : int Decrease(const char *pMinuend, const char *pSubtrahend, 
char **ppResult)
Input Param  : const char *pMinuend     被减数，以\0表示字符串结束
               const char *pSubtrahend  减数，以\0表示字符串结束
Output       : char **ppResult          减法结果，必须以\0表示字符串结束
Return Value : 成功返回0   失败返回-1
*****************************************************************************/
int Decrease(const char *pcMinuend, const char *pcSubtrahend, char **ppResult)
{
#if TEST
    printf("\r\n ============== Origin Num ==============");
    printf("\r\n pcMinuend = %s", pcMinuend);
    printf("\r\n pcSubtrahend = %s", pcSubtrahend);
#endif   
    BigNumSub(pcMinuend, pcSubtrahend, ppResult);
    printf("\r\n ppResult = %s", *ppResult);

    return 0;
}

int main(void)
{
    char str1[] = "999999";
    char str2[] = "11111111111";
    char *str3 = NULL;
    Decrease(str1, str2, &str3);
    return 0;
}

 

文章标签：
算法
移动开发
guitar_zp
目录
相关文章
小空门123-30335
|
5月前
|
Python
首先，我们可以从基本的数学运算开始，比如加法、减法、乘法、除法等。
首先，我们可以从基本的数学运算开始，比如加法、减法、乘法、除法等。
小空门123-30335
36 0
一只大鸽子
|
6月前
PAT乙级 1017大数除法
PAT乙级 1017大数除法
一只大鸽子
31 0
阿甘兄
|
算法 C++
91 C++ - 常用算数生成算法
91 C++ - 常用算数生成算法
阿甘兄
37 0
是八哥啊~
|
存储 Java 大数据
实现两个大数的加法运算（使用栈实现）
实现两个大数的加法运算
是八哥啊~
224 0
实现两个大数的加法运算（使用栈实现）
子夜的星-27391
|
存储 算法
经典算法之异或运算（无进位相加）
经典算法之异或运算（无进位相加）
子夜的星-27391
354 0
经典算法之异或运算（无进位相加）
姚先生Y
|
算法 C++
跟着姚桑学算法-不用加减乘除做加法
剑指offer算法
姚先生Y
78 0
跟着姚桑学算法-不用加减乘除做加法
姚先生Y
|
存储 算法
跟着姚桑学算法-64位整数乘法
基本算法题
姚先生Y
115 0
跟着姚桑学算法-64位整数乘法
夜孤城
7-2 一元多项式的乘法与加法运算 (20 分)
7-2 一元多项式的乘法与加法运算 (20 分)
夜孤城
149 0
真题OK撒
7-41 大数的乘法 (10 分)
7-41 大数的乘法 (10 分)
真题OK撒
82 0
kyxdt4sqtmta6
|
存储 算法
高精度加法，模拟大数的加法运算
在处理特别大的数相加特别大的数的时候，long long不能直接通过加法算出结果的时候，可以通过高精度算法处理这些数的相加具体·思路如下； 首先 1 . 这些数存到数组的时候该如何排列，是个位放在第一位还是最后一位放到第一位，由于数的相加的候常常出现进位，常在最后一位加上一个数，而加上数的话往往在数组最后一位加上数比较方便，所以我们把第个位放在数组第一位 2.其次在调用模拟大数相加的函数中，我们该如何处理同一位上数相加出现的进位呢，我们可以设置一个 t 存储数组上某位相加最后吧 t%10 ,就可以得到想要的数，同时在 t / 10 如果 t 会的得到 1 或者 0.
kyxdt4sqtmta6
142 0

热门文章

最新文章

  • 1
    Gitlab----使用Docker方式安装部署Gitlab
  • 2
    Mac搭建安卓模拟器（支持M1/M2/M3/M4）
  • 3
    java报错javax.net.ssl.SSLHandshakeException:  sun.security.validator.ValidatorException
  • 4
    开发人员各级岗位胜任力模型
  • 5
    Hive之数据倾斜的原因和解决方法
  • 6
    【Java】留下没有基础眼泪的面试题
  • 7
    iptables系列教程（二）| iptables语法规则
  • 8
    13.4. 临时表是否需要建索引
  • 9
    共享的两种方式
  • 10
    Andriod动态布局
  • 1
    Linux 各发行版安装 ping 命令指南
    42
  • 2
    Linux缓存管理：如何安全地清理系统缓存
    101
  • 3
    《CMake：掌控 C++人工智能项目编译的魔法棒》
    35
  • 4
    《C++人工智能开发 IDE 全解析：助力智能创新之路》
    37
  • 5
    《解锁 Eigen 库在 C++人工智能项目中的潜能与优化之道》
    35
  • 6
    《解析 MXNet 的 C++版本在分布式训练中的机遇与挑战》
    25
  • 7
    《探索 Caffe2 的 C++接口在移动设备上的性能优化之路》
    27
  • 8
    docker高级篇（大厂进阶）：安装redis集群
    45
  • 9
    Lyra：SmartMore 联合香港多所高校推出的多模态大型语言模型，专注于提升语音、视觉和语言模态的交互能力
    63
  • 10
    LatentLM：微软联合清华大学推出的多模态生成模型，能够统一处理和生成图像、文本、音频和语音合成
    48

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍

    • 相关电子书

    更多
  • 图解算法小抄
  • 数据+算法定义新世界
  • 超全算法笔试-模拟题精解合集

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。