编写任意精度整数运行包。要使用类似于多项式运算的方法。计算在2^4000内数字0到9的分布

数据结构与算法分析——c语言描述 练习3.9 答案

这道题真的是要狗带了。。。。我的在vs2015 release模式只能计算到2的60次方。超过60次方就会一直卡在那。估计是有些地方没有优化好。可能是栈溢出什么的，因为函数存在相互之间互相调用。

使用了我的多项式代码。日后再更新代码吧。目前也不知道怎样解决。

2016.4.6

终于更新了，问题出在函数互相调用，虽然不是栈溢出，而是调用insertMonomial的时候会删除p，假如连续两个都是0要删除的时候，深一层删除上一层的指针，返回来的一层要访问，造成访问已经释放的内存。也就是野指针。

更新了进制10000，输出的时候除了第一位不足4位数的要前面补上0

list.h

typedef struct {
int Coefficient;//系数
int Exponent;//指数
}ElementType;

#ifndef _List_H
#define _List_H

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

List CreatList();
List MakeEmpty(List L);
int IsEmpty(List L);
int IsLast(Position P, List L);
Position Find(ElementType X, List L);
void Delete(ElementType X, List L);
Position FindPrevious(ElementType X, List L);
void Insert(ElementType X, Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);
void deleteNext(Position p);

#endif

list.c

#include"list.h"
#include<stdlib.h>
#include"fatal.h"

struct  Node {
ElementType Element;
Position Next;
};

int elementCmp(ElementType e1, ElementType e2) {
return e1.Coefficient == e2.Coefficient && e1.Exponent == e2.Exponent;
}

List CreatList() {
List l = malloc(sizeof(struct Node));
if (l == NULL)
Error("out of memory");
l->Next = NULL;
return l;
}

List MakeEmpty(List L) {
if (L == NULL)
Error("L is not created");
DeleteList(L);
L->Next = NULL;
return L;

}

int IsEmpty(List L) {
return L->Next == NULL;
}

int IsLast(Position P, List L) {
return P->Next == NULL;
}

Position Find(ElementType X, List L) {
Position P;
P = L->Next;
while (P != NULL&& elementCmp(P->Element, X))
{
P = P->Next;
}
return P;
}

void Delete(ElementType X, List L) {
Position P;
P = FindPrevious(X, L);
if (!IsLast(P, L)) {
Position TmpCell = P->Next;
P->Next = TmpCell->Next;
free(TmpCell);
}
}

Position FindPrevious(ElementType X, List L) {
Position P;
P = L;
while (P->Next != NULL&& elementCmp(P->Next->Element, X))
P = P->Next;
return P;
}

void Insert(ElementType X, Position P) {
Position tmpCell;
tmpCell = (List)malloc(sizeof(struct Node));
if (tmpCell == NULL)
FatalError("Out of space!!");
tmpCell->Element = X;
tmpCell->Next = P->Next;
P->Next = tmpCell;
}

void DeleteList(List L) {
Position p;
p = L->Next;
L->Next = NULL;
while (p != NULL) {
Position tmp;
tmp = p->Next;
free(p);
p = tmp;
}
}

Position Header(List L) {
return L;
}

Position First(List L) {
return L->Next;
}

Position Advance(Position P) {
return P->Next;
}

ElementType Retrieve(Position P) {
return P->Element;
}

void deleteNext(Position p) {
Position temp = p->Next->Next;
free(p->Next);
p->Next = temp;
}

biginteger.h

#ifndef _biginteger_h
#define _biginteger_h

#include<stdlib.h>
#include"list.h"

typedef struct {
List list;
}Biginteger;

struct  Node {
ElementType Element;
Position Next;
};

Biginteger creatBiginteger();
void ZeroBiginteger(Biginteger big);
void MulBiginteger(const  Biginteger big1, const  Biginteger big2, Biginteger bigProd);
void printBiginteger(Biginteger big);

#endif

biginteger.c

#include"biginteger.h"
#include<stdio.h>

static int BASE = 10000;

static  void carry(ElementType * e, Biginteger big);

Biginteger creatBiginteger() {
Biginteger poly;
poly.list = CreatList();
return poly;
}

static void insertMonomial(ElementType e, Biginteger big) {
Position p = big.list;
while (Advance(p) != NULL && Advance(p)->Element.Exponent > e.Exponent)
p = Advance(p);
if (Advance(p) == NULL) {
Insert(e, p);
}
else if (Advance(p)->Element.Exponent != e.Exponent)
Insert(e, p);
else {
Advance(p)->Element.Coefficient += e.Coefficient;
if (Advance(p)->Element.Coefficient >= BASE)
carry(&(Advance(p)->Element), big);
//if (Advance(p)->Element.Coefficient == 0)这里不能要，有时会删除在更深一层删除了p
//deleteNext(p);
}
}

static void carry(ElementType * e, Biginteger big) {
ElementType carry_e;
carry_e.Coefficient = (*e).Coefficient / BASE;
carry_e.Exponent = (*e).Exponent + 1;
(*e).Coefficient = (*e).Coefficient % BASE;
insertMonomial(carry_e, big);
}

void ZeroBiginteger(Biginteger big) {
MakeEmpty(big.list);
}

void MulBiginteger(const  Biginteger big1, const  Biginteger big2, Biginteger bigProd) {
ZeroBiginteger(bigProd);
ElementType prod;
for (Position i = big1.list->Next; i != NULL; i = Advance(i)) {
for (Position j = big2.list->Next; j != NULL; j = Advance(j)) {
prod.Coefficient = Retrieve(i).Coefficient * Retrieve(j).Coefficient;
prod.Exponent = Retrieve(i).Exponent + Retrieve(j).Exponent;
if (prod.Coefficient >= BASE)
carry(&prod, bigProd);
insertMonomial(prod, bigProd);
}
}
}

void printBiginteger(Biginteger big) {

Position p = Advance(big.list);
printf("%d", Retrieve(p).Coefficient);
p = Advance(p);
while (p) {

printf("%04d", Retrieve(p).Coefficient);//当一个单元不满足的时候够进制的个数的时候，要补上0
p = Advance(p);
}
printf("\n");
}

main.c

#include"biginteger.h"
#include<math.h>
#define MAXN 1000

Biginteger powOfBiginteger(Biginteger big, int p) {
Biginteger PowersOfXO[MAXN];
int cnt, i;
Biginteger ans = creatBiginteger();

ElementType e;
e.Coefficient = 1;
e.Exponent = 0;
Insert(e, ans.list);

cnt = (int)log2(p);
PowersOfXO[0].list = big.list;
for (i = 1; i <= cnt; i++) {
PowersOfXO[i] = creatBiginteger();
MulBiginteger(PowersOfXO[i - 1], PowersOfXO[i - 1], PowersOfXO[i]);
}
i = 0;
while (p > 0) {//将n转换为2进制，如果为1乘
if (p % 2 == 1) {
Biginteger temp = creatBiginteger();
MulBiginteger(ans, PowersOfXO[i], temp);
ans.list = temp.list;
}
i++;
p /= 2;
}
return ans;
}

int main() {
Biginteger b1;
b1 = creatBiginteger();

ElementType e;
e.Coefficient = 2;
e.Exponent = 0;

Insert(e, b1.list);

printBiginteger(powOfBiginteger(b1, 4000));
}