编程计算器-表达式求值（浮点数、标识符的实现）-顺序表链表实现-同维度向量运算-C语言

#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
	int *elem;
	int length;
	int listsize;
}Sqlist;  //线性表的顺序表储存结构
typedef struct{
	double coef;
	int expn;
}term;   //一元多项式的每一项 
typedef struct LNode{
	term data;
	struct LNode *next;
}LNode,*LinkList; //线性表的链表储存结构 
typedef LinkList polynomail;
typedef struct{
	term* elem;
	int length;
	int listsize;
}Sq_p;   //建立多项式的顺序表 
typedef struct{
	char* base;
	char* top;
	int stacksize;
}SqStack1; 
typedef struct{
	double* base;
	double* top;
	int stacksize; 
}SqStack2;
void InitList_Sq(Sqlist &l){
	//构造一个空的线性表
	l.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));
	if(!l.elem)
		exit(OVERFLOW);
	l.length=0;
	l.listsize=LIST_INIT_SIZE;
}
void InitList_P(Sq_p &l){
	l.elem=(term*)malloc(LIST_INIT_SIZE*sizeof(term));
	if(!l.elem)
		exit(OVERFLOW);
	l.length=0;
	l.listsize=LIST_INIT_SIZE;
}
void ClearList_Sq(Sqlist &l){  //清空一个线性表 
	l.length=0;
	l.listsize=LIST_INIT_SIZE;
}
void ClearList_P(Sq_p &l){  //清空一个线性表 
	l.length=0;
	l.listsize=LIST_INIT_SIZE;
}
int ListLength(Sqlist l){   //查看一个线性表的长度 
	if(!l.elem)
		exit(OVERFLOW);
	return l.length;
}
int ListLength_P(Sq_p l){   //查看一个线性表的长度 
	if(!l.elem)
		exit(OVERFLOW);
	return l.length;
}
void Show(Sqlist l){   //遍历 
	printf("("); 
	for(int i=0;i<l.length;i++){
		if(i<l.length-1)
			printf("%d,",l.elem[i]);
		else
			printf("%d)\n",l.elem[i]);
	}
}
int ListInsert_Sq(Sqlist &l,int i,int e){  //插入元素，成功返回1，不成功返回0 
	if(i<1||i>l.length+1)  //防御处理 
		return 0;
	if(l.length>=l.listsize){
		int* newbase=(int*)realloc(l.elem,(l.listsize+LISTINCREMENT)*sizeof(int));  //realloc申请更大的空间，同时释放原空间 
		if(!newbase)
			exit(OVERFLOW);
		l.elem=newbase;
		l.listsize=l.listsize+LISTINCREMENT;
	} 
	if(!l.length){
		l.elem[0]=e;
		l.length++;
	//	Show(l);
		return 1;
	}
	int* q=&(l.elem[i-1]);
	for(int* p=&(l.elem[l.length-1]);p>=q;--p)
		*(p+1)=*p;
	*q=e;
	++l.length;
	//printf("%d\n",l.length);
	//Show(l);
	return 1;
}
int ListInsert_P(Sq_p &l,int i,term e){  //插入多项式元素 
	if(i<1||i>l.length+1)  //防御处理 
		return 0;
	if(l.length>=l.listsize){
		term* newbase=(term*)realloc(l.elem,(l.listsize+LISTINCREMENT)*sizeof(term));  //realloc申请更大的空间，同时释放原空间 
		if(!newbase)
			exit(OVERFLOW);
		l.elem=newbase;
		l.listsize=l.listsize+LISTINCREMENT;
	} 
	if(!l.length){
		l.elem[0].coef=e.coef;
		l.elem[0].expn=e.expn;
		l.length++;
		return 1;
	}
	term* q=&(l.elem[i-1]);
	for(term* p=&(l.elem[l.length-1]);p>=q;--p)
		*(p+1)=*p;
	*q=e;
	++l.length;
	//printf("%d %lf\n",e.coef,e.expn);
	return 1;
}
int ListDelete(Sqlist &l,int i,int e){  //删除元素，成功返回1，不成功返回0 
	if(i<1||i>l.length)
		return 0;
	int* p=&(l.elem[i-1]);
	e=*p;
	int* q=l.elem+l.length-1;
	for(++p;p<=q;++p)   
		*(p-1)=*p;
	--l.length; 
}
int ListDelete_P(Sq_p &l,int i,term e){  //删除多项式元素，成功返回1，不成功返回0 
	if(i<1||i>l.length)
		return 0;
	term* p=&(l.elem[i-1]);
	e=*p;
	term* q=l.elem+l.length-1;
	for(++p;p<=q;++p)   
		*(p-1)=*p;
	--l.length; 
}
Sqlist add(Sqlist l1,Sqlist l2){  //线性表向量的加法运算 
	Sqlist l3;
	int e1,e2;
	InitList_Sq(l3);
	for(int i=0;i<l1.length;i++){
		ListInsert_Sq(l3,i+1,l1.elem[i]+l2.elem[i]);
	}
	return l3;
}
Sqlist sub(Sqlist l1,Sqlist l2){  //线性表向量的减法运算 
	Sqlist l3;
	int e1,e2;
	InitList_Sq(l3);
	for(int i=0;i<l1.length;i++)
		ListInsert_Sq(l3,i+1,l1.elem[i]-l2.elem[i]);
	return l3;
}
Sqlist multiply(Sqlist l1,Sqlist l2){  //线性表向量的数乘运算 
	Sqlist l3;
	int e1,e2;
	InitList_Sq(l3);
	for(int i=0;i<l1.length;i++)
		ListInsert_Sq(l3,i+1,l1.elem[i]*l2.elem[i]);
	return l3;
}
double cos_value(Sqlist l1,Sqlist l2){   //计算两个向量的夹角余弦值 
	double t1=0,t2=0,t3=0;
	for(int i=0;i<l1.length;i++){
		t1=t1+l1.elem[i]*l2.elem[i];
		t2=t2+l1.elem[i]*l1.elem[i];
		t3=t3+l2.elem[i]*l2.elem[i];
	}
	t2=sqrt(t2);
	t3=sqrt(t3);
	return t1/(t2*t3);    
} 
void Show_P(Sq_p l){   //显示出多项式 
	for(int i=0;i<l.length;i++){
		if(i<l.length-1){  //未到多项式最后一项 
			if(l.elem[i].expn){
				printf("%.2lfx^%d+",l.elem[i].coef,l.elem[i].expn);}
			else{
				printf("%.2lf+",l.elem[i].coef);
			} 
		}
		else{  //到了多项式最后一项 
			if(l.elem[i].coef){
				printf("%.2lfx^%d",l.elem[i].coef,l.elem[i].expn);}
			else
				printf("%.2lf",l.elem[i].coef);
			} 
		} 
	printf("\n");
} 
void Sort_P(Sq_p &l){   //对存放一元多项式的顺序表进行排序
	int min_e=999;
	int min_pos=-1;
	for(int i=0;i<l.length;i++){
		for(int j=i;j<l.length;j++){
			if(l.elem[j].expn<min_e){
				min_e=l.elem[j].expn;
				min_pos=j;
			}
		}  //此时已经找到了最小的次数 
		int cmp=l.elem[i].expn;
		double cmp1=l.elem[i].coef;
		l.elem[i].expn=min_e;
		l.elem[i].coef=l.elem[min_pos].coef;
		l.elem[min_pos].expn=cmp;
		l.elem[min_pos].coef=cmp1;   //交换排序主体 
		min_e=999;  //重置最小值 
	}
}
void Add_P(Sq_p l1,Sq_p l2){     //对两个多项式进行加法运算 
	Sq_p l3;
	InitList_P(l3);
	double coef=0;   
	int i=0,j=0,k=1;   //i,j指示目前进行运算的元素
						//k指示目前l3中元素进行的个数 
	while(i<l1.length&&j<l2.length){
		if(l1.elem[i].expn<l2.elem[j].expn) { //如果l1的次数小于l2次数 
			ListInsert_P(l3,k++,l1.elem[i]);   //在l3的第k（k=1）个元素之前插入元素，同时k++
			i++;		
		} 
		else if(l1.elem[i].expn>l2.elem[j].expn){
			ListInsert_P(l3,k++,l2.elem[i]);   //在l3的第k（k=1）个元素之前插入元素，同时k++
			j++;
		}
		else{
			term t1;
			t1.coef=l1.elem[i].coef+l2.elem[j].coef;
			t1.expn=l1.elem[i].expn;
			if(t1.coef){   //如果系数不为0，才把它放进去 
				ListInsert_P(l3,k++,t1);
				i++;
				j++;
			}
		}
}
	if(i>=l1.length){
		for(j;j<l2.length;j++){
			ListInsert_P(l3,j+1,l2.elem[i]);
		}
	}
	else{
		for(i;i<l1.length;i++){
			ListInsert_P(l3,i+1,l1.elem[i]);
		}
	}
	Show_P(l3); 
}
void Sub_P(Sq_p l1,Sq_p l2){     //对两个多项式进行减法运算 
	Sq_p l3;
	InitList_P(l3);
	double coef=0;   
	int i=0,j=0,k=1;   //i,j指示目前进行运算的元素
						//k指示目前l3中元素进行的个数 
	while(i<l1.length&&j<l2.length){
		if(l1.elem[i].expn<l2.elem[j].expn) { //如果l1的次数小于l2次数 
			ListInsert_P(l3,k++,l1.elem[i]);   //在l3的第k（k=1）个元素之前插入元素，同时k++
			i++;		
		} 
		else if(l1.elem[i].expn>l2.elem[j].expn){
			l2.elem[j].coef=-l2.elem[j].coef;   //相减后系数变为负数 
			ListInsert_P(l3,k++,l2.elem[i]);   //在l3的第k（k=1）个元素之前插入元素，同时k++
			j++;
		}
		else{
			term t1;
			t1.coef=l1.elem[i].coef-l2.elem[j].coef;
			t1.expn=l1.elem[i].expn;
			if(t1.coef){   //如果系数不为0，才把它放进去 
				ListInsert_P(l3,k++,t1);
				i++;
				j++;
			}
		}
	}
	if(i=l1.length){
		for(i;i<l2.length;i++){
			l2.elem[i].coef=-l2.elem[i].coef;
			ListInsert_P(l3,i,l2.elem[i]);
		}
	}
	else{
		for(i;i<l1.length;i++){
			ListInsert_P(l3,i,l1.elem[i]);
		}
	}
	Show_P(l3);
}
int Seek_P(term* a,int expn){  //若数组中存在指数为expn，则返回位置。否则返回第一个空位置
	int i=0;
	for(i=0;i<100;i++){
		if(a[i].expn==expn)   //找到指数，返回指数所在位置 
			return i;
		if(a[i].expn==0&&a[i].coef==0)  //找到了第一个空位还没有找到，跳出循环 
			break; 
	}
	return i;  //没有找到，返回下一个空闲值 
} 
void Multiply_P(Sq_p l1,Sq_p l2){  //两个多项式相乘 
	term a[100];
	term b;
	int expn=0;
	Sq_p l3;   
	InitList_P(l3);  //初始化一个多项式的顺序表 
	double coef; //临时储存指数和系数 
	for(int i=0;i<100;i++){
		a[i].coef=0;
		a[i].expn=0;
	} //将系数和指数清零
	for(int i=0;i<l1.length;i++){
		for(int j=0;j<l2.length;j++){
			expn=l1.elem[i].expn+l2.elem[j].expn;  //多项式相乘，指数相加
			coef=l1.elem[i].coef*l2.elem[j].coef;
			int t=Seek_P(a,expn);
			a[t].expn=expn;  
			a[t].coef=a[t].coef+coef;   
		}
	} 
	int j=1;
	for(int i=0;i<100;i++){
		if(a[i].coef){
			b.coef=a[i].coef;
			b.expn=a[i].expn;
			ListInsert_P(l3,j++,b);
		}
	}   //将所有系数非0的元素都插入顺序表中
	Sort_P(l3);
	Show_P(l3); 
} 
void Derivation_P(Sq_p l,int n){  //对一个多项式求n次导数
	term a[100];
	Sq_p l1;
	InitList_P(l1); 
	int expn=0;
	double coef=0;
	for(int i=0;i<100;i++){
		a[i].coef=0;
		a[i].expn=0;
	}
	if(n>l.elem[l.length-1].expn){//如果求导次数大于最高次数，则直接返回0
		printf("导数为0\n");
		return;
	} 
	for(int i=0;i<l.length;i++){
		if(l.elem[i].expn>=n){  //只有这种情况这一项的导数才不为0 
			expn=l.elem[i].expn;  //用于等会求系数的项 
			coef=l.elem[i].coef;
			for(int j=0;j<n;j++){
				coef=coef*expn;
				expn--;
			} //算出了求导后的系数值，此时需将次数值重置 
			expn=l.elem[i].expn-n;
			int t=Seek_P(a,expn);
			a[t].coef=coef;
			a[t].expn=expn;  //将新值放入数组中 
		}
	}
	for(int i=0;;i++){
		if(!a[i].coef)
			break;
		ListInsert_P(l1,i+1,a[i]);
	}
	Show_P(l1);	
	return;
}
void CreatePolyn(polynomail &P){//建立一元多项式的有序链表P 
	P=(polynomail)malloc(sizeof(LNode));
	P->next=NULL;
	/*printf("请按次数从大到小的顺序依次输入次数，系数\n");
	for(int i=0;i<m;i++){
		polynomail q=(polynomail)malloc(sizeof(LNode));
		scanf("%d %lf",&q->data.expn,&q->data.coef);//输入指数、系数
		q->next=P->next;
		P->next=q;   //头插入 
	} */
}
void PrintPolyn(polynomail P){  //打印一元多项式P 
	polynomail q=P->next;
	int j=1;
	while(q){
		if(q->data.coef>0&&j!=1)
			printf("+");
		if(q->data.expn&&q->data.coef)
			printf("%.3fx^%d",q->data.coef,q->data.expn);
		else if(q->data.expn==0&&q->data.coef)
			printf("%.3f",q->data.coef);  //若次数为0则不打印出x 
		q=q->next;
		j++; 
	} 
	printf("\n");	
}
void Sort_S(polynomail &P){  //对输进来的一元多项式按次数从小到大的顺序排列 
	int min=999;
	polynomail min_p=P; //指向最小元素的指针 
	polynomail q=P,p=P;
	if(!q->next->next)
		return;  
	while(q->next){
		min=q->next->data.expn;    
		p=q->next;
		while(p){
			if(p->data.expn<min){
				min=p->data.expn;
				min_p=p;
			}
			p=p->next;
		}
		if(q->next->data.expn>min){   //最小的元素不在当前位置的情况，需要交换 
			int cmp1=q->next->data.expn;
			double cmp2=q->next->data.coef; 
			q->next->data.coef=min_p->data.coef;
			q->next->data.expn=min_p->data.expn;
			min_p->data.expn=cmp1;
			min_p->data.coef=cmp2;
		}
		q=q->next;
		min=999;  //此处需要将min值恢复，否则会影响下一轮的判断 
	}
} 
int PolynLength(polynomail P){
	polynomail q=P;
	int j=0;
	while(q->next){
		q=q->next;
		j++;
	}
	return j;
}
void ListInsert_L(polynomail &Pa,term e){  //往链表的尾端加入e元素 
	polynomail p=Pa;
	while(p->next)
		p=p->next;
	polynomail p3=(polynomail)malloc(sizeof(LNode));
	p3->data=e;
	p->next=p3;
	p3->next=NULL;
}
void AddPolyn(polynomail Pa,polynomail Pb,polynomail &Pc){
	polynomail la=Pa->next,lb=Pb->next;
	polynomail lc;
	Pc=lc=Pa;
	while(la&&lb){
		if(la->data.expn<lb->data.expn){//la的指数比lb小
			lc->next=la;
			lc=la;
			la=la->next;
		} 
		else if(la->data.expn>lb->data.expn){  //la的指数比lb大 
			lc->next=lb;
			lc=lb;
			lb=lb->next;
		}
		else if(la->data.expn==lb->data.expn){  //la指数与lb指数相同
			la->data.coef=la->data.coef+lb->data.coef;
			lc->next=la; 
			lc=la;
			la=la->next;
			lb=lb->next; //lb的指针也需后移一位 
		}
	}
	lc->next=la?la:lb;
	free(Pb);
}
void SubtractPolyn(polynomail Pa,polynomail Pb,polynomail &Pc){
	polynomail la=Pa->next,lb=Pb->next;
	polynomail lc;
	Pc=lc=Pa;
	while(la&&lb){
		if(la->data.expn<lb->data.expn){//la的指数比lb小
			lc->next=la;
			lc=la;
			la=la->next;
		} 
		else if(la->data.expn>lb->data.expn){  //la的指数比lb大 
			lb->data.coef=-lb->data.coef; 
			lc->next=lb;
			lc=lb;
			lb=lb->next;
		}
		else if(la->data.expn==lb->data.expn){  //la指数与lb指数相同
			la->data.coef=la->data.coef-lb->data.coef;
			lc->next=la; 
			lc=la;
			la=la->next;
			lb=lb->next; //lb的指针也需后移一位 
		}
	}
	if(la)
		lc->next=la;
	else{
		polynomail lb1=lb;
		while(lb){
			lb->data.coef=-lb->data.coef;
			lb=lb->next;
		}
		lc->next=lb1; 
	}
	free(Pb);
} 
void MultiplyPolyn(polynomail Pa,polynomail Pb){  //两个链表方式存储的一元多项式相乘
	polynomail Pc;
	CreatePolyn(Pc);
	polynomail p1=Pa,p2=Pb;
	term t;
	int expn;
	double coef; 
	while(p1->next){
		while(p2->next){   //对第一个多项式的每一项，遍历第二个多项式的每一项 
		expn=p1->next->data.expn+p2->next->data.expn;
		coef=p1->next->data.coef*p2->next->data.coef;
		t.expn=expn;
		t.coef=coef;
		ListInsert_L(Pc,t);  //往链表里插入元素 
		p2=p2->next;
		}
		p1=p1->next;
		p2=Pb;   
	}  //此时，相乘的项已经都放进了链表Pc
	//PrintPolyn(Pc);  //√ 
	polynomail p3=Pc,p4;  
	while(p3->next){
		p4=p3->next;
		while(p4->next){
			if(p4->next->data.expn==p3->next->data.expn){
				p3->next->data.coef=p3->next->data.coef+p4->next->data.coef; 
				p4->next=p4->next->next;  //删除p4->next节点 
			}
			p4=p4->next;   //节点向后移动 
		}
		p3=p3->next; 
	}
	PrintPolyn(Pc);
}
void Derivation_S(polynomail Pc,int n){  //对一个多项式求n次导 
	polynomail p=Pc;
	double coef;
	int expn;
	while(p->next)
		p=p->next;
	if(p->data.expn<n){
		printf("所求导数为0\n");
		return;
	} 
	p=Pc;
	while(p->next){
		expn=p->next->data.expn;
		coef=p->next->data.coef;
		for(int i=0;i<n;i++){
			coef=coef*expn;
			expn--;
		}
		expn=p->next->data.expn-n;
		p->next->data.expn=expn;
		p->next->data.coef=coef; 
		p=p->next; 
	} 
	PrintPolyn(Pc);
}
void InitStack2(SqStack2 &s){
	s.base=(double*)malloc(STACK_INIT_SIZE*sizeof(double));
	if(!s.base)
		exit(OVERFLOW);
	s.stacksize=STACK_INIT_SIZE;
	s.top=s.base;
	return; 
}
double GetTop2(SqStack2 s){
	if(s.top==s.base){
		printf("ERROR When get top\n");
		return 0;
	}
	double e=*(s.top-1);
	return e;
}
void Push2(SqStack2 &s,double e){
	if(s.top-s.base>=s.stacksize){
		s.base=(double*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(double));
		if(!s.base)
			exit(OVERFLOW);
		s.top=s.base+s.stacksize;
		s.stacksize+STACKINCREMENT; 
	}
	*s.top=e;
	s.top++;
	return;
}
void Pop2(SqStack2 &s,double &e){  //若栈不空，则删除s的栈顶元素，用e返回值 
	if(s.top==s.base){
		printf("ERROR When pop\n");
		return;
	}
	e=*--s.top;
	return;
}
void InitStack1(SqStack1 &s){
	s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));
	if(!s.base)
		exit(OVERFLOW);
	s.stacksize=STACK_INIT_SIZE;
	s.top=s.base;
	return;
}
char GetTop1(SqStack1 s){  //用e返回栈顶元素 
	if(s.top==s.base){
		printf("ERROR When get top\n");
		return '0'; 
	}
	char e=*(s.top-1);
	return e;
}
void Push1(SqStack1 &s,char e){  //在栈中插入元素为e的新的栈顶元素 
	if(s.top-s.base>=s.stacksize){
		s.base=(char*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));
		if(!s.base)
			exit(OVERFLOW);
		s.top=s.base+s.stacksize;
		s.stacksize+STACKINCREMENT;
	}
	*s.top=e;
	s.top++;
	return;
}
void Pop1(SqStack1 &s,char &e){  //若栈不空，则删除s的栈顶元素，用e返回值 
	if(s.top==s.base){
		printf("ERROR When pop\n");
		return;
	}
	e=*--s.top;
	return;
}
int In(char e){  //判断读入的字符是否为运算符 
	if(e=='+'||e=='-'||e=='*'||e=='/'||e=='('||e==')'||e=='#')
		return 1;  //是运算符
	else 
		return 0;//不是运算符	
} 
int Letter(char e){    //判断输入的字符是否为字母 
	if((e>='a'&&e<='z')||(e>='A'&&e<='Z'))
		return 1;
	else
		return 0;
}
char Compare(char a,char b){ //比较运算符的优先级 
	char f;
	if(a=='+'||a=='-'){
		if(b=='+'||b=='-'||b==')'||b=='#')
			f='>';
		else if(b=='('||b=='*'||b=='/')
			f='<';
	}
	else if(a=='*'||a=='/'){
		if(b=='+'||b=='-'||b=='*'||b=='/'||b==')'||b=='#')
			f='>';
		else if(b=='(')
			f='<';
	}
	else if(a=='('){
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')
			f='<';
		else if(b==')')
			f='=';		
	}
	else if(a==')'){
		if(b=='+'||b=='-'||b=='*'||b=='/'||b==')'||b=='#')
			f='>';
	}
	else if(a=='#'){
		if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')
			f='<';
		else if(b=='#')
			f='=';
	}
	return f;
}
double cal(double a,char theta,double b){  //运算，theta为运算符 
	double c;//保存结果
	if(theta=='+')
		c=a+b;
	else if(theta=='-')
		c=a-b;
	else if(theta=='*')
		c=a*b;
	else if(theta=='/')
		c=a/b;
	return c;
}
double EvaluateExpression(char* s){  //表达式求值 
	SqStack1 OPTR;  //存放操作符 
	SqStack2 OPND;  //存放运算数 
	char c,theta,x;
	double a=0,b=0;
	InitStack2(OPND);
	InitStack1(OPTR);
	Push1(OPTR,'#');
	int i=0;
	bool decimal=false;  //判断存入的数据是否是小数 
	c=s[i++];
	while(c!='#'||GetTop1(OPTR)!='#'){
		if(!In(c)&&!Letter(c)){
			double d=0;
			while(!In(c)){
				if(decimal==false){  //如果不为小数 
					d=d*10+c-'0';
					c=s[i++];  //正常运算 
				}
				if(c=='.'){
					decimal=true;
					c=s[i++];
				}
				if(decimal==true){
					d=(d*10+c-'0')/10;
					c=s[i++];
				}
			}
			Push2(OPND,d);
			decimal=false;
		} 
		else if(Letter(c)){   //有字母出现，代表出现了单变量 
			while(!In(c))  //当它是数字时
				c=s[i++];
			printf("请输入变量的值\n");
			double d=0;
			scanf("%lf",&d);
			Push2(OPND,d); 
		}
		else if(In(c)){
			switch(Compare(GetTop1(OPTR),c)){
				case'<':
					Push1(OPTR,c);
					c=s[i++];
					break;
				case'>':
					Pop1(OPTR,theta);
					Pop2(OPND,b);
					Pop2(OPND,a);
					Push2(OPND,cal(a,theta,b));
					break;
				case'=':
					Pop1(OPTR,x);
					c=s[i++];
					break;
			}
		}
	} 
	return GetTop2(OPND);
}
int main(){
	int dim=-1,ans1=-1,ans2=-1,ans3=-1,ans4=-1;
	Sqlist l1,l2,l3;
	Sq_p  l4,l5,l6;
	polynomail l7,l8,l9;
	int a[10]={0};  //存放向量数据的临时数组 
	term cmp;  //存放一元多项式数据 
	char s[100]; //存放表达式的数组 
	printf("===========Welcome to CJY's Counter(* ▽* )／========\n");
	printf("请输入向量的维数\n"); 
	scanf("%d",&dim); 
	printf("请输入第一组向量的数据\n");
	InitList_Sq(l1);
	for(int i=0;i<dim;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=dim;i++){
		ListInsert_Sq(l1,i,a[i-1]);
	}
	printf("你输入的第一组向量为(");
	for(int i=0;i<dim;i++){
		if(i<dim-1)
			printf("%d,",a[i]);
		else
			printf("%d)\n",a[i]);
	}
	printf("请输入第二组向量的数据\n"); 
	InitList_Sq(l2);
	for(int i=0;i<dim;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=dim;i++){
		ListInsert_Sq(l2,i,a[i-1]);
	}
	printf("你输入的第二组向量为(");
	for(int i=0;i<dim;i++){
		if(i<dim-1)
			printf("%d,",a[i]);
		else
			printf("%d)\n",a[i]);
	}
	for(int i=0;i<10;i++)
		a[i]=0; //清零      
	printf("若你想进行加法运算，请输入1，减法运算请输入2，向量的数乘请输入3，计算夹角的余弦值请输入4\n");
	scanf("%d",&ans1);
	if(ans1==1)
		l3=add(l1,l2);
	if(ans1==2){
		printf("如果你想让第一个向量为被减数，请输入1，反之请输入0\n");
		scanf("%d",&ans2); 
		if(ans2==1)
			l3=sub(l1,l2);
		else
			l3=sub(l2,l1);
	}
	if(ans1==3)
		l3=multiply(l1,l2);		
	printf("运算的结果是："); 
	if(ans1<=3)
		Show(l3);
	else
		printf("%lf",cos_value(l1,l2));
	printf("现在，所有的数据将被清空\n");
	ClearList_Sq(l1);
	ClearList_Sq(l2);
	ClearList_Sq(l3); 
	ans1=-1,ans2=-1;   //清空储存选择的信息 
	printf("如果你想用顺序表完成一元多项式相关的运算，请输入1，如果想用链表请输入2\n");
	scanf("%d",&ans4);
	if(ans4==1){
		printf("请输入第一个一元多项式的项数\n");
		
		scanf("%d",&dim); 
		printf("请输入第一个一元多项式的系数和次数\n");  //用顺序表存储一元多项式的信息 
		InitList_P(l4);
		for(int i=0;i<dim;i++){
			scanf("%lf %d",&cmp.coef,&cmp.expn);  //输入一元多项式的系数和次数；
			ListInsert_P(l4,i+1,cmp);
		}
		Sort_P(l4);  //对l4按次数从小到大排序
		Show_P(l4);
		printf("请输入第二个一元多项式的项数\n");
		scanf("%d",&dim);
		printf("请输入第二个一元多项式的系数和次数\n");   
		InitList_P(l5);
		for(int i=0;i<dim;i++){
			scanf("%lf %d",&cmp.coef,&cmp.expn);  //输入一元多项式的系数和次数；
			ListInsert_P(l5,i+1,cmp);
		}
		Sort_P(l5);  //对l5按次数从小到大排序	
		Show_P(l5);
		printf("如果你想进行加法运算，请输入1，减法运算请输入2，乘法运算请输入3\n");
		scanf("%d",&ans1);  
		if(ans1==1)
			Add_P(l4,l5); 
		else if(ans1==2){
			printf("如果你想让第一个多项式为被减项，请输入1，否则请输入2\n");
			scanf("%d",&ans2);
			if(ans2==1)
				Sub_P(l4,l5);
			else
				Sub_P(l5,l4);
		}
		else if(ans1==3){
			Multiply_P(l4,l5);
		}
		ans1=-1,ans2=-1;
		printf("如果你想进行求导运算，请输入1\n");
		scanf("%d",&ans1);
		if(ans1==1){
			printf("如果你想对第一个多项式求导，请输入1，否则请输入2\n");
			scanf("%d",&ans2);
			printf("请输入想求导的次数\n");
			scanf("%d",&ans3);
			if(ans2==1)
				Derivation_P(l4,ans3);
			else
				Derivation_P(l5,ans3);
		}
	}
	else{
		printf("请输入第一个多项式的项数\n");
		scanf("%d",&dim);
		CreatePolyn(l7);  
		printf("请输入第一个一元多项式的系数和次数\n");
		for(int i=0;i<dim;i++){
			scanf("%lf %d",&cmp.coef,&cmp.expn); 
			ListInsert_L(l7,cmp);
		} 
		Sort_S(l7);
		PrintPolyn(l7);
		printf("请输入第二个一元多项式的项数\n");
		scanf("%d",&dim);
		CreatePolyn(l8);
		printf("请输入第二个一元多项式的系数和次数\n");
		for(int i=0;i<dim;i++){
			scanf("%lf %d",&cmp.coef,&cmp.expn);
			ListInsert_L(l8,cmp);
		} 
		Sort_S(l8);
		PrintPolyn(l8);
		printf("如果你想做加法，请输入1，想做减法请输入2，想做乘法请输入3\n");
		CreatePolyn(l9);
		scanf("%d",&ans1);
		if(ans1==1){
			AddPolyn(l7,l8,l9);
			PrintPolyn(l9);
		}
		else if(ans1==2){
			printf("如果你想让第一个多项式为被减项，请输入1，否则请输入2\n");
			scanf("%d",&ans2);
			if(ans2==1){
				SubtractPolyn(l7,l8,l9);
				PrintPolyn(l9);
			}
			else{
				
				SubtractPolyn(l8,l7,l9);
				PrintPolyn(l9);
			}
		}
		else{
			MultiplyPolyn(l7,l8);
		}	
		ans1=-1;
		ans2=-1;
		printf("如果你想求导数，请输入1\n");
		scanf("%d",&ans1);
		if(ans1==1){
			printf("如果是对第一个多项式求导，请输入1，否则请输入2\n");
			scanf("%d",&ans2);
			printf("请输入求导的次数\n");
			scanf("%d",&ans3);
			if(ans2==1){  //对第一个多项式求导 
				Derivation_S(l7,ans3);
			} 
			else{
				Derivation_S(l8,ans3);
			}
		}
	}
	printf("请输入你想要计算的表达式的值"); 
	scanf("%s",s);
	double f=EvaluateExpression(s);
	printf("结果为：%lf",f); 
	return 0;
}