两个长数字串全乘双向链表实现

//两个长数字串全乘双向链表实现

#include <iostream>

#include <cmath>

#include <stdlib.h>

using namespace std;

class DblList;

class DblNode{//双向链表结点类定义;

friend class DblList;

private:

int data;

DblNode *lLink , *rLink ;

public:

DblNode(int value,DblNode* left,DblNode *right):data(value),lLink(left),rLink(right){}

DblNode(int value):data(value),lLink(NULL),rLink(NULL){}

};

//

class DblList{

public :

DblList (int unique_Val) ;

~DblList () ;

void input () ;//P 从键盘输入一串长整数构造双向循环链表

int Length ( ) const ;//P 求链表中有效结点个数 ,即链表长度

void Insertfront (const int & value) ;//P 将新元素插入到链表头

void Insertrear (const int &value) ;//P 将新元素插入到链表尾

void print () ;//P 打印输出链表表示的长整数

void convolution (DblList&la ,DblList &lb) ;//P 求两数卷积运算

void multiplication (DblList& ld) ;// P 卷积结果分离成商数;

private :

DblNode *first;

};

//

DblList::DblList(int unique_Val){

first = new DblNode (unique_Val) ;

first->rLink = first->lLink = first ;

}

DblList::~DblList{

DblNode * p , * q ;

p =first - > rLink ;

while (p ! =first) {

　　q = p ;p = p - > rLink ;

　　delete q ;

}

delete first ;

}

int DblLst ∷ Length () const{//P 求链表的长度(结点个数)

DblNode 　* p =first - > rLink ;

int count = 0 ;

while (p ! =first) {p = p - > rLink ;count + + ;}

return count ;

}

void DblList ∷Insertrear (const int & value)//插入元素到链表尾

{ 　 DblNode * p ;

p = new DblNode (value) ;

p - > rLink =first ;

p - > lLink =first - > lLink ;

first - > lLink - > rLink = p ;

first - > lLink = p ;

}

void DblList ∷Insertfront (const int & value)// 插入元素到链表头

{

DblNode * p ;

p = new DblNode (value) ;

if (first - > rLink = =first

{ p - > rLink =first ;

　 p - > lLink =first ;

　 first - > lLink =first - > lLink = p ;

}

else

{

p - > lLink =first - > lLink ;

p - > rLink =first ;

first - > lLink - > rLink = p ;

first - > lLink = p ;

}

}

void DblList ∷ input () {//从键盘输入一串长数字串建立其对应的双向循环链表;

char ch ;

int chint ;

int i = 0 ,k = 0 ;

cout < <“请输入长数字串 ,按回车键或 Ctrl+ C结束:” ;

while ( ! cin. eof () )

{

ch = cin. get () ;//接收从键盘输入的长数字串中的一个字符;

if (ch = =‘P n’ ) break ;

if (ch = =‘- ’ ) first - > data = - 1 ;

else

if (ch > =‘0’ &&ch < =‘9’ )

{

　 chint = ch -‘0’ ;

　Insertrear (chint) ;

　k + + ;

}

else if (ch = =‘.’ ) i = k ;

else{

　　　　 cerr < <“输入错误 !”< < endl ;

　　　　 exit (1) ;

}

}

if (i = = 0) i = k ;

first - > data = (first - > data) * i ;

}

void DblList ∷ print () {//打印输出链表所对应的长整数

DblNode * p ;

int ij ,k ;

p =first ;

i = abs (first -> data) ;

k =Length () ;

cout < <“\ n长整数为:” ;

if (p - > data < 0)

cout<<‘- ’ ;

j = 0 ;

while (p - > rLink ! =first) {

　 p = p - > rLink ;

　 cout < < p - > data ;

　 j + + ;

　 if (j = = i&& i ! = k) cout < <‘.’ ;

}

cout < <‘\ n’ ;

}

void DblList ∷conv olution (DblList& la , DblList &lb)//求两数的卷积结果

{

DblNode * p1 , * p2 , * pp1 , * pp2 ;

int c1 ,c2 ,c* ;

c1 = la. first - > data ;

c1 = la.Length () - abs (c1) ;

c2 = lb. first - > data ;

c2 = lb.Length () - abs (c2) ;

c* = abs (c1) + abs (c2) ;

if ( (la. first - > data) * (1b. first - > data) < 0)

c* = c* * ( - 1) ;

first - > data = c* ;

p1 = la. first - > lLink ;p2 = lb. first - > lLink ;

while (p2 ! = lb. first)

{ pp2 = p2 ;

　 int k = 0 ;

　 pp1 = p1 ;

　 while (pp2 ! = 1b. first & &pp1 ! = la. first)

　 {

　　 k = k + (pp1 - > data) * (pp2 - > data) ;

　　 pp2 = pp2 - > rLink ;

　　 pp1 = pp1 - > lLink ;

　 }

Insertfront (k) ;

p2 = p2 - > lLink ;

}

p1 = p1 - > lLink ; p2 = lb. first - > rLink ;

while (pl ! = la. first)

{

　 pp1 = p1 ;

　 pp2 = p2 ;

　 int k = 0 ;

　 while (pp1 ! = la. first &&pp2 ! = lb. first)

　 {

　　 k = k + (pp1 - > data) * (pp2 - > data) ;

　　 pp1 = pp1 - > lLink ;

　　 pp2 = pp2 - > rLink ;

　}

　Insertfront (k)

　p1 - p1 - > lLink ;

}

}

void DblList ∷ multiplication (DblList&ld)//卷积结果分离成商数;

{

DblNode * p ;

int k ,ij = 0 ,c = 0 ;

p = 1d. first - > lLink ;

while (p ! = ld. first)

{ k = c + p - > data ;

　 i = k %10 ;

　 c = kP 10 ;

　 Insertfront (i) ;

　 j + + ;

　 p = p - > lLink ;

}

while (c ! = 0)

{

　 i = c %10 ;

　 c = cP 10 ;

　 Insertfront (i) ;

　 j + + ;

}

k = ld. first - > data ;

i = j - abs (k) ;

first - > data = i ;

if (k < 0)

first->data = (first->data)*(-1) ;

}

void main () {

DblList pa (1) ;//构造初始双向循环链表pa

DblList pb (1) ;//构造初始双向循环链表pb

DblList pc (1) ;//构造初始双向循环链表pc

DblList pd (1) ;//构造初始双向循环链表pd

pa. input () ;//从键盘输入待计算的长整数串1并建立其对应的双向循环链表pa

pb. input () ;//从键盘输入待计算的长整数串2并建立其对应的双向循环链表pb

pc. conv olution (pa ,pb)//进行卷积运算并将其结果放在链表pc 中;

pd. multiplication (pc)// 将卷积结果转化为两数相乘的结果值放在双向链表pd中;

pd. print () ;// 输出结果值

}

/*运行结果示例

示例1 :

请输入长数字串 ,按回车键或 Ctrl + C结束:

12. 3456789012

请输入长数字串 ,按回车键或 Ctrl + C结束:

- 4567. 891234

12. 3456789012 3 - 4567. 891234 = - 56393.

7184305702320808

示例2 :

请输入长数字串 ,按回车键或 Ctrl + C结束:

1234567890

请输入长数字串 ,按回车键或 Ctrl + C结束:

23. 123456789

1234567890 3 23. 123456789 = 2854477257.

501905210

PS:

加法、 减法和除法等运算又如何实现呢 ? 用

带表头结点的双向循环链表表示的长数字串 ,对

于加、 减法运算 ,主要要处理好小数点对齐和进

位、 借位等问题 ,然后按位相加减即可实现;而对

于除法运算可以看成是除数的倒数乘以被除数 ,

即除法运算转化成乘法运算实现。如要求 x

y

的

值 ,我们可以把它看成是 x ×1

y

,而 1

y

可以用牛顿

法则的迭代计算公式: Ui+1 = Ui ×(2 - y ×Ui

) 进

行若干次迭代,根据精度要求精确到小数点后若

干位再与 x 相乘即可得到结果;迭代计算需要一

个初值 ,它必须满足大于0且小于1

y

的2倍 ,可通

过一个函数来实现。 限于篇幅,在此没有给出全部

程序。

*/