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

main.cpp

#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;
}

queue.h:

#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;
}

}