链表实现任意精度整数运算

《数据结构与算法分析》上的一道练习题，原题要求使用类似于多项式运算的方法，编写任意精度整数运算程序，计算在2^4000中0到9的分布。大概说一下自己的想法吧，如有错误欢迎批评指正！

这题思路还是容易的，链表结构如下，每个链表单元保存大整数的一位即可，做乘法时从个位开始相乘，如果产生进位则暂存用以加到高位。对于X^N，若底数X有M位（十进制），则算法复杂度为O（M*N^2）。

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

struct Node
{
    int Element;
    PtrToNode Next;
};

上面的思路看着挺自然的，但仔细一想，发现也有不妥之处。因为链表中元素的数据类型是int32的，如果只用来保存一个10以内的数是很大的浪费，而且乘法的过程中会频繁的产生进位，导致算法效率较低。

解决办法也很简单，改变一下链表中数据的进制，选取10000进制（为了在做乘法时不至于溢出，而且在输出十进制数时只要补零就可以了），问题就迎刃而解了。

用C实现了上述算法后，发现还是比较稳的，估算了一下，相对于十进制的算法，速度可以提升4倍左右（为什么？？）。但有一点，就是底数X不能太大，最大只能取大概5位数，否则乘法时就会发生溢出，这样就很不开心了，为了能算更大的数（下面纯粹是为了好玩），我把链表里数的数据类型改成了：

struct Node
{
    unsigned long long int Element;
    PtrToNode Next;
};

看着就热血沸腾有木有! 然后把10,000进制改成了1,000,000,000进制，这样就能把底数的运算极限提到10位十进制的数了。

程序是下面这样的：

/*输入底数和指数，输出结果链表*/
List BigNumber(int base, int exp)
{
    int carry;//进位
    int tmpele;
    List L;
    Position P, Tmp;
    L = Init(); P = L; //创建一个空链表

    /*初始化，塞进去第一个底数*/
    tmpele = base;
    while (tmpele > 0)
    {
        Tmp = malloc(sizeof(struct Node));
        if (Tmp == NULL)
        {
            printf("Failed to Initialize!!!");
            exit(-1);
        }
        Tmp->Element = tmpele % 1000000000;
        P->Next = Tmp;
        P = Tmp;
        P->Next = NULL;

        tmpele /= 1000000000;
    }

    /*主程序*/
    /*主要思路：当前位=当前位*底数+进位，如果大于1000000000则产生进位*/
    for (int i = 1; i < exp; i++)
    {
        carry = 0;
        for (P = L->Next; P != NULL; P = P->Next)
        {
            P->Element = P->Element*base + carry;
            carry = P->Element / 1000000000;
            if (P->Element >= 1000000000)
            {
                P->Element %= 1000000000;
                tmpele = carry;
                if (P->Next == NULL)//链表加长
                {
                    while (tmpele > 0)
                    {
                        Tmp = malloc(sizeof(struct Node));
                        if (Tmp == NULL)
                        {
                            printf("Failed to Initialize!!!");
                            exit(-1);
                        }
                        Tmp->Element = tmpele % 1000000000;
                        P->Next = Tmp;
                        P = Tmp;
                        P->Next = NULL;

                        tmpele /= 1000000000;
                    }
                }
            }
        }
    }

    return L;
}

经过这样一番折腾，运算效率相对于十进制提升了一个量级（因为这相当于把X的位数M降低了一个量级），下面计算0-9分布什么的就很简单了。
放张图感受一下：

这是2^4000.不够刺激？！

这是2^123456.

这是2101350789^12345.
11万位。。。

其实可以用牺牲空间的办法实现更大的底数，比如用链表数据依然用十进制，数据类型还是 unsigned long long int 的话，底数可以达到18位十进制数。再大就没办法了，同时也没啥意思了，毕竟计算机能处理的数据是有限的，本来就不可能达到任意精度。这里实现的任意精度也只是在一定范围内相对而言的。