C++大数据运算{开n次方(二分法逐渐逼近求解)，n次方，小数，符号，加减乘除模！}

#include <iostream>
#include "queue.h"
using namespace std;
int main()
{
using namespace work;
Queue<int> q;
Queue<int> p;
Queue<int> w;
char ch;
int select=0;
char *m = new char [1000];
cout<<"欢迎来到大数据的四则运算：>"<<endl;
cin.getline(m,1000);
GetNumber(ch,m,&q,&p);
//	MOD_POWER(&q,&p,&w);
//	w.view();
switch(ch)
{
case '+':
ADD_S(&q,&p,&w);
w.view();
break;
case '-':
DEC_S(&q,&p,&w);
w.view();
break;
case '*':
MUL_S(&q,&p,&w);
w.view();
break;
case '/':
{
cout<<"1进入整数运算，2进入小数运算:"<<endl;
cin>>select;
if(select==2)
{
DIV_R(&q,&p,&w);
w.view();
}
else
{
DIV_S(&q,&p,&w);
w.view();
}
}
break;
case '%':
MOD(&q,&p,&w);
w.view();
break;
case '^':
POWER_S(&q,&p,&w);
w.view();
break;
case '@':
MOD_POWER(&q,&p,&w);
w.view();
default:
break;
}
return 0;
}

#pragma once
#include <iostream>
using namespace std;
namespace work
{
template<typename T>
class Queue;
template<typename T>
void ADD(Queue<T> *q,Queue<T> *p,Queue<T> *m);

template<typename T>
void DEC(Queue<T> *q,Queue<T> *p,Queue<T> *m);

template<typename T>
void DIV(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3);

enum WHAT
{
Plus,
Minus,
};//确定符号位。

template<typename T>
class DList
{
friend class Queue<T>;
private:
int data;//数据域
DList *prev;
DList *next;
};

template<typename T>
class Queue
{
private:
DList<T> *head;
DList<T> *tail;
int size;//链表长度。
int Split;//小数点位数。
public:
Queue()
{
head = tail = new DList<T>();
tail -> next = NULL;
head -> prev = NULL;
size = 0;
Split = 0;
}
void Set_Split(int x)
{
Split = x;//设置小数点位数
}
int COMPLATE_SPLIT(const Queue<T> *list)
{
if(Split > list->Split)
{
return 1;
}
else if(Split == list->Split)
{
return 0;
}
else
{
return -1;
}
}//比较小数点位数
int Get_Split()
{
return Split;
}//得到小数点位数
void Head_val(int x)
{
head->data = x;
}//设置头节点的值（所谓的符号位）
int Tail_Return()
{
return tail->data;
}//返回尾节点值
int Head_Return()
{
return head->data;
}//返回头节点的值，也就是符号位。
Queue(const Queue &q)
{
head = tail =new DList<T>();
tail -> next = NULL;
head ->prev = NULL;
size = 0;
DList<T> *p = (q.head)->next;
while(p!=NULL)
{
this->push_back(p->data);
p=p->next;
}
}
Queue operator = (const Queue &q)
{
head = tail = new DList<T>();
tail -> next =NULL;
head -> prev = NULL;
size = 0;
DList<T> *p = (q.head)->next;
while(p!=NULL)
{
this->push_back(p->data);
p = p->next;
}
}
bool IS_empy()
{
return ((size>0));
}
int SIZE()
{
return size;
}
void CLEAR()
{
DList<T> *p = head->next;
tail = head;
tail -> next = NULL;
head ->prev = NULL;
while(p != NULL)
{
DList<T> *q = p->next;
delete p;
p = q;
}
}
int Get_Number()
{
int temp = 0;
Queue<T> mylist = *this;
for(int i = this->SIZE();i>0;--i)
{
temp = temp*10 + this->PopHead();
}
*this = mylist;
return temp;
}//将链表转化为数字。
void POW(int x)
{
Queue<T> list1;
Queue<T> list2;
Queue<T> list3;
Queue<T> list4 = *this;
for(int i=0;i<x;i++)
{
ADD(this,&list1,&list2);
list3 = list2;
list1.CLEAR();
list2.CLEAR();
list1 = list3;
*this = list4;
}
this->CLEAR();
*this = 	list3;
}//list*[1-9]。
int PopTail()
{
if(size==0)
{
return 0;
}
else
{
int x = tail->data;
DList<T> *p = tail->prev;
delete tail;
tail = p;
tail->next = NULL;
size--;
return x;
}
}

int PopHead()
{
if(size == 0)
{
return 0;
}
else
{
T x = head->next->data;

DList<T> *p = head->next;

if ( p->next != NULL )
{
p->next->prev = head;
head->next = p->next;
//p->next->prev = head;
}
else
{
head->next = NULL;
tail = head;
}
delete p;
p = NULL;
size--;
return x;
}
}

int DEC_D(Queue<T> *list1)
{
this->DeleteZero();
if(this->COMPLATE(list1)==-1)
{
return 0;
}
Queue<T> mylist1;
Queue<T> mylist2 = *list1;
//Queue<T> mylist3 = *this;
int n = 0;
while(this->COMPLATE(list1)>=0)
{
DEC(this,list1,&mylist1);
n++;
this->CLEAR();
list1->CLEAR();
*this = mylist1;
mylist1.CLEAR();
*list1 = mylist2;
}
list1->CLEAR();
//	*this = mylist3;
*list1 = mylist2;
return n;
}

void push_front(T x)
{
DList<T> *s = new DList<T>();
s -> data = x;
if(head == tail)
{
//	s -> next = tail;
//	tail -> prev = s;
head -> next = s;
s -> prev = head;
tail = s;
tail -> next = NULL;
}
else
{
s -> next = head->next;
head -> next -> prev = s;
head -> next = s;
s -> prev = s;
}
size++;
}
int COMPLATE(Queue<T> *list2)
{
if(size>list2->size)
{
return 1;
}
else if(size == list2->size)
{
DList<T> *q = head->next;
DList<T> *p = list2->head->next;
while(q != NULL && p!=NULL)
{
if(q->data>p->data)
{
return 1;
}
else if(q->data==p->data)
{
p = p->next;
q = q->next;
}
else
{
return -1;
}
}
return 0;
}
else
{
return -1;
}//比较链表大小。
}
void push_back(T x)
{
DList<T> *s = new DList<T>();
s -> data = x;
if(head == tail)
{
s -> next = tail;
tail -> prev = s;
head -> next = s;
s -> prev = head;
tail = s;
tail -> next = NULL;
}
else
{
tail -> next = s;
s -> prev = tail;
tail = s;
tail -> next = NULL;
}
size++;
}
DList<T> *Get_Split_Pos()
{

DList<T> *p = tail;
int n = Split;
while(n--)
{
p = p->prev;
}
return p;
}//得到小数点的位置地址。
void Delete_Tail_Zero()
{
DList<T> *p = tail;
if(Split!=0)
{
while(this->Tail_Return()==0)
{
this->PopTail();
if(Split>0)
{
Split--;
}
if(Split==0)
{
return ;
}
}
}
else
{
return ;
}
}//删除小数点后面的0.
void view()
{
if(head->next->data == 0 &&head->next->next==NULL)
{
cout<<"0";
return ;
}
this->Delete_Tail_Zero();
DList<T> *p = head;
DList<T> *q = tail;
if(head->data == Minus)
{
cout<<"-";
}
int n = Split;
int m = size;
if(n==0)
{
while(p->next!=NULL)
{
this->DeleteZero();
cout<<Get_Pos(p->next);
p = p->next;
}
}
else if(n<size)
{
DList<T> *m = Get_Split_Pos();
while(p->next!=NULL)
{
if(m==p)
{
cout<<".";
}
cout<<Get_Pos(p->next);
p = p -> next;
}
}
else if(n == size)
{
cout<<"0.";
while(p->next!=NULL)
{
cout<<Get_Pos(p->next);
p = p->next;
}
}
else if(n>size)
{
if(n==Split)
{
cout<<"0.";
}
while(n-- > size)
{
cout<<"0";
}
while(p->next!=NULL)
{
cout<<PopHead();
}
}
cout<<endl;
}

int Get_Tail()
{
return tail->data;
}

void DeleteZero()
{
DList<T> *p = head->next;
while(p!=NULL)
{
if(p->data == 0)
{
PopHead();
p = p->next;
}
else
{
return ;
}
}
if(p==NULL)
{
this->push_front(0);
}
}//删除链表前面的0
int Get_Head_Val()
{
if(Get_Pos_Ref()==NULL)
{
return 0;
}
return head->next->data;
}
int Get_Pos(DList<T> *&pos)
{
return pos->data;
}
DList<T> * Get_Pos_Ref()
{
return head->next;
}
};

void DeleteSpace(char *&str)
{
while(*str==' ')
str++;
}//删除空格
bool IS_INT(char ch)
{
return ((ch-'0')>=0 && (ch-'0')<=9);
}
int GET_INT(char ch)
{
return (ch-'0');
}
char INT_CHAR(int x)
{
return ('0'+x);
}

bool IS_Split(char ch)
{
return (ch=='.');
}
template<typename T>
void GetNumber(char &ch,char *&str,Queue<T> *list1,Queue<T> *list2)
{
int n =0;
int m = 0;
DeleteSpace(str);
if(!IS_INT(*str))
{
if((*str)==('-'))
list1->Head_val(Minus);
else
list1->Head_val(Plus);
str++;
}
while(IS_INT(*str) || IS_Split(*str))
{
if(IS_Split(*str))
{
str++;
m = 1;
}
list1->push_back(GET_INT(*str));
if(m==1)
{
n++;
}
str++;
}
list1->Set_Split(n);
n = 0;
m = 0;
DeleteSpace(str);
ch = *str;
str++;
DeleteSpace(str);
if(!IS_INT(*str))
{
if(*str=='-')
list2->Head_val(Minus);
else
list2->Head_val(Plus);
str++;
}
while(*str!='\0' )
{
if(IS_Split(*str))
{
str++;
m = 1;
}
if(m==1)
{
n++;
}
list2->push_back(GET_INT(*str));
str++;
}
list2->Set_Split(n);
}

template<typename T>
void ADD(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
Queue<T> mylist1 = *list1;
Queue<T> mylist2 = *list2;
int flog = 0;

while(flog!=0 || list1->IS_empy() || list2->IS_empy())
{
int a = list1->PopTail();
int b = list2->PopTail();
if(a+b+flog>=10)
{
list3->push_front(a+b+flog-10);
flog = 1;
}
else
{
list3->push_front(a+b+flog);
flog = 0;
}
}
*list1 = mylist1;
*list2 = mylist2;
}

template<typename T>
void ADD_T(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
//	list3->DeleteZero();
int BOOL = list1->COMPLATE(list2);
if(list1->Head_Return()==Minus)
{
if(list2->Head_Return()==Minus)
{
ADD(list1,list2,list3);
list3->Head_val(Minus);
}
else
{
if(BOOL>0)
{
DEC(list1,list2,list3);
//		list3->DeleteZero();
list3->Head_val(Minus);
}
else if(BOOL==0)
{
list3->push_back(0);
}
else
{
DEC(list2,list1,list3);
//	list3->DeleteZero();
}
}
}
else
{
if(list2->Head_Return()==Plus)
{
ADD(list1,list2,list3);
}
else
{
if(BOOL>0)
{
DEC(list2,list1,list3);
list3->DeleteZero();
}
else if(BOOL==0)
{
list3->push_back(0);
}
else
{
DEC(list2,list1,list3);
list3->DeleteZero();
list3->Head_val(Minus);
}
}
}
}

template<typename T>
void ADD_S(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
if(list1->Get_Split()==0 && list2->Get_Split()==0)
{
ADD_T(list1,list2,list3);
}
else
{
int BOOL = list1->COMPLATE_SPLIT(list2);
int L_1 = list1->Get_Split();
int L_2 = list2->Get_Split();
if(BOOL>0)
{
while(L_1!=L_2)
{
list2->push_back(0);
L_2++;
}
ADD_T(list1,list2,list3);
list3->Set_Split(list1->Get_Split());
}
else if(BOOL == 0)
{
ADD_T(list1,list2,list3);
list3->Set_Split(list1->Get_Split());
}
else
{
while(L_1!=L_2)
{
list1->push_back(0);
L_1++;
}
ADD_T(list1,list2,list3);
list3->Set_Split(list2->Get_Split());
}
}
}

template<typename T>
void DEC(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
Queue<T> mlist1 = *list1;
Queue<T> mlist2 = *list2;
if(list1->COMPLATE(list2)==0)
{
list2->push_front(0);
return ;
}
else if(list1->COMPLATE(list2)==1)
{
int flog = 0;
while(flog != 0 || list1->IS_empy() || list2->IS_empy())
{
int a = list1->PopTail();
int b = list2->PopTail();
if((a+flog)<b)
{
list3->push_front(10+a-b+flog);
flog = -1;
}
else
{
list3->push_front(a-b+flog);
flog = 0;
}
}
}
else
{
int flog = 0;
while(flog != 0 || list1->IS_empy() || list2->IS_empy())
{
int b = list1->PopTail();
int a = list2->PopTail();
if((a+flog)<b)
{
list3->push_front(10+a-b+flog);
flog = -1;
}
else
{
list3->push_front(a-b+flog);
flog = 0;
}
}
}
list3->DeleteZero();
*list1 = mlist1;
*list2 = mlist2;
}

template<typename T>
void DEC_T(Queue<T>*list1,Queue<T>*list2,Queue<T>*list3)
{
int L_1 = list1->Head_Return();
int L_2 = list2->Head_Return();
int BOOL = list1->COMPLATE(list2);
if(L_1==Plus)
{
if(L_2==Plus)
{
if(BOOL>=0)
{
DEC(list1,list2,list3);
}
else
{
DEC(list2,list1,list3);
list3->Head_val(Minus);
}
}
else
{
ADD(list1,list2,list3);
}
}
else
{
if(L_2==Plus)
{
ADD(list1,list2,list3);
list3->Head_val(Minus);
}
else
{
if(BOOL>0)
{
DEC(list1,list2,list3);
list3->Head_val(Minus);
}
else if(BOOL=0)
{
list3->push_back(0);
}
else
{
DEC(list2,list1,list3);
}
}
}
}

template<typename T>
void DEC_S(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
int L_1 = list1->Get_Split();
int L_2 = list2->Get_Split();
int BOOL = list1->COMPLATE_SPLIT(list2);
if(L_1==0 && L_2==0)
{
DEC_T(list1,list2,list3);
}
else if(L_1>L_2)
{
while(L_2!=L_1)
{
list2->push_back(0);
L_2++;
}
DEC_T(list1,list2,list3);
list3->Set_Split(list1->Get_Split());
}
else if(L_1<L_2)
{
while(L_1!=L_2)
{
list1->push_back(0);
L_1++;
}
DEC_T(list1,list2,list3);
list3->Set_Split(list2->Get_Split());
}
else
{
DEC_T(list1,list2,list3);
list3->Set_Split(list2->Get_Split());
}
}
template<typename T>
void MUL(Queue<T> *list1,Queue<T> *list2,Queue<T>*list3)
{
if((list1->SIZE()==1 && list1->Tail_Return()==0) || (list2->SIZE()==1 && list2->Tail_Return()==0))
{
list3->push_back(0);
return;
}
Queue<T> mylist1 = *list1;
Queue<T> mylist2;

Queue<T> mylist3;
int n = list2->SIZE();
int i;
int j;

for(i=n;i>0;i--)
{
int m = list2->PopHead();
list1->POW(m);
for(j = 0;j<i-1;j++)
{
list1->push_back(0);
}
ADD(list1,&mylist2,&mylist3);
list1->CLEAR();
mylist2.CLEAR();
*list1 = mylist1;
mylist2 = mylist3;
mylist3.CLEAR();
*list3 = mylist2;
if(i==0)
{
return ;
}
}
}

template<typename T>
void MUL_T(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
int L_1 = list1->Head_Return();
int L_2 = list2->Head_Return();
int BOOL = list1->COMPLATE(list2);
if((L_1==Minus && L_2==Minus) || (L_1==Plus && L_2==Plus))
{
MUL(list1,list2,list3);
}
else
{
MUL(list1,list2,list3);
list3->Head_val(Minus);
}
}

template<typename T>
void MUL_S(Queue<T> *list1,Queue<T>*list2,Queue<T>*list3)
{
int L_1 = list1->Get_Split();
int L_2 = list2->Get_Split();
if(L_1==0 && L_2==0)
{
MUL_T(list1,list2,list3);
}
else if(L_1!=0 &&L_2!=0)
{
if(L_1==1 || L_2==1)
{
MUL_T(list1,list2,list3);
list3->Set_Split(L_1*L_2+1);
}
else
{
MUL_T(list1,list2,list3);
list3->Set_Split(L_1*L_2);
}
}

else
{
if(L_1==0)
{
MUL_T(list1,list2,list3);
list3->Set_Split(L_2);
}
else
{
MUL_T(list1,list2,list3);
list3->Set_Split(L_1);
}
}
//	list3->Delete_Tail_Zero();
}

template<typename T>
void DIV(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
Queue<T> mlist1 = *list1;
Queue<T> mlist2 = *list2;
if(list2->Get_Head_Val()==0)
{
cout<<"what's wrong with you !!!"<<endl;
return ;
}
if(list1->COMPLATE(list2)<0)
{
list3->push_front(0);
return ;
}
else if(list1->COMPLATE(list2)==0)
{
list3->push_front(1);
return;
}
else
{
Queue<T> mylist;
Queue<T> mylist2 = *list2;
Queue<T> result;
while(list1->IS_empy())
{
mylist.push_back(list1->PopHead());
int n = mylist.DEC_D(list2);
result.push_back(n);
}
*list3 = result;
}
list3->DeleteZero();
*list1 = mlist1;
*list2 = mlist2;
}

template<typename T>
void DIV_T(Queue<T>*list1,Queue<T>*list2,Queue<T> *list3)
{
int L_1 = list1->Head_Return();
int L_2 = list2->Head_Return();
int BOOL = list1->COMPLATE(list2);
if((L_1==Minus && L_2==Minus) || (L_1==Plus && L_2==Plus))
{
DIV(list1,list2,list3);
}
else
{
DIV(list1,list2,list3);
list3->Head_val(Minus);
}
}

template<typename T>
void DIV_S(Queue<T> *list1,Queue<T>*list2,Queue<T>*list3)
{
int L_1 = list1->Get_Split();
int L_2 = list2->Get_Split();
if(L_1==L_2)
{
DIV_T(list1,list2,list3);
}
else if(L_1>L_2)
{
DIV_T(list1,list2,list3);
list3->Set_Split(L_1-L_2);
}
else
{
int n = L_2-L_1;
while(n--)
{
list1->push_back(0);
}
DIV_T(list1,list2,list3);
list3->Set_Split(0);
}
}

template<typename T>
void DIV_R(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
int i = 0;
int j = 0;
cout<<"你想取几位小数："<<endl;
cin>>i;
int L_1 = list1->Get_Split();
int L_2 = list2->Get_Split();
if(L_1==L_2 )
{
for(;j<i;j++)
{
list1->push_back(0);
}
DIV_S(list1,list2,list3);
list3->Set_Split(i);
}
else if(L_1>L_2)
{
for(j=0;j<(i-(L_1-L_2));j++)
{
list1->push_back(0);
}
DIV_S(list1,list2,list3);
list3->Set_Split(i);
}
else
{
for(j=0;j<i+(L_2-L_1);j++)
{
list1->push_back(0);
}
list2->DeleteZero();
list2->Set_Split(0);
DIV_S(list1,list2,list3);
list3->Set_Split(i);
}
}

template<typename T>
void MOD(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
if(list2->Get_Head_Val()==0)
{
cout<<"what's wrong with you !!!"<<endl;
return ;
}
if(list1->COMPLATE(list2)<0)
{
*list3 = *list1;
return ;
}
else if(list1->COMPLATE(list2)==0)
{
list3->push_front(0);
return;
}
else
{
Queue<T> mylist;
Queue<T> mylist2 = *list2;
while(list1->IS_empy())
{
mylist.push_back(list1->PopHead());
mylist.DEC_D(list2);
}
*list3 = mylist;
}
list3->DeleteZero();
}

template<typename T>
void POWER(Queue<T> *list1,Queue<T> *list2,Queue<T>*list3)
{
if(list1->Get_Head_Val()==0)
{
list3->push_back(0);
return ;
}
if(list2->Get_Head_Val()==0)
{
list3->push_back(1);
return ;
}
int m = list2->Get_Number();
Queue<T> mylist1 = *list1;
Queue<T> mylist2 = *list1;
Queue<T> mylist3;
for(int i=0;i<m-1;++i)
{
MUL(list1,&mylist1,&mylist3);
mylist1.CLEAR();
mylist1 = mylist3;
mylist3.CLEAR();
list1->CLEAR();
*list1 = mylist2;
}
*list3 = mylist1;
}

template<typename T>
void POWER_T(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
if(list2->Get_Tail()%2==0 || list1->Head_Return()==Plus)
{
POWER(list1,list2,list3);
}
else
{
POWER(list1,list2,list3);
list3->Head_val(Minus);
}
}

template<typename T>
void POWER_S(Queue<T> *list1,Queue<T>*list2,Queue<T>*list3)
{
int L_0 = list1->Get_Split();
int n = list2->Get_Number();
POWER_T(list1,list2,list3);
list3->Set_Split(L_0*n);
}

template<typename T>
void MOD_POWER(Queue<T> *list1,Queue<T> *list2,Queue<T> *list3)
{
     if(list2->Get_Number()==1)
      {
          list3->push_back(1);
          return ;
       }
        int n = list1->Get_Number();
int i = list2->SIZE()/n;
Queue<T> mylist1;
mylist1.push_back(1);
Queue<T> mylist2;
mylist2.push_back(1);
while(--i>0)
{
mylist1.push_back(0);
mylist2.push_back(0);
}
mylist2.push_back(0);
        mylist2.push_back(0);
   Queue<T> list;
list.push_back(2);
Queue<T> xlist;
xlist.push_back(1);
Queue<T> ylist;
while(mylist1.COMPLATE(&mylist2)<0)
{

Queue<T> mlist1;
Queue<T> mlist3;
Queue<T> mlist4;
ADD_T(&mylist1,&mylist2,&mlist1);
DIV_T(&mlist1,&list,&mlist3);
POWER_T(&mlist3,list1,&mlist4);
if(mlist4.COMPLATE(list2)>0)
{
mylist2.CLEAR();
DEC(&mlist3,&xlist,&ylist);

mylist2 = ylist;
ylist.CLEAR();
}
else if(mlist4.COMPLATE(list2)<0)
{
mylist1.CLEAR();
ADD(&mlist3,&xlist,&ylist);

mylist1 = ylist;
ylist.CLEAR();
}
else
{
*list3 = mlist3;
return ;
}
}
Queue<T> zlist;
ADD(&mylist1,&mylist2,&zlist);
Queue<T> result;
DIV_S(&zlist,&list,&result);
*list3 = result;
}

}