123456789=a.c

插入运算符算法

#include "stdio.h"
#include "stdlib.h"
#include "conio.h"


#define maxlen 20

typedef struct {
	char stack[maxlen];
	int top;
}stack1;//符号栈

typedef struct{
	int stack[maxlen];
	int top;
}stack2;//数字栈


void InitStack1(stack1 *s){  /*初始化stack1类空栈*/
	s->top=-1;
}

void InitStack2(stack2 *s){ //初始化stack2类空栈
	s->top=-1;
}

int Isnull1(stack1 *s){//判断符号栈是否为空 空返回1，不空返回0
	if(s->top==-1)
		return 1;
	else return 0;
}

int Isnull2(stack2 *s){//判断数字栈是否为空，空返回1，不空返回0
	if(s->top==-1)
		return 1;
	else 
		return 0;
}

void push1(stack1 *s,char ch){//符号入栈
	s->top++;
	s->stack[s->top]=ch;
}

void push2(stack2 *s,int ch){//数字入栈
	s->top++;
	s->stack[s->top]=ch;
}



void pop1(stack1 *s){//符号出栈
	s->top--;
}

void pop2(stack2 *s){//数字出栈
	
	s->top--;
}

int Getnum1(stack1 *s){//通过top值获取当前栈中元素总数，top=0代表有一个
	return s->top;
}

int Getnum2(stack2 *s){//同Getnum1
	return s->top;
}
char Gettop1(stack1 *s){//获取符号栈中的最上面的符号
	return s->stack[s->top];
}

int Gettop2(stack2 *s){//获取数字栈最上面的数字
	return s->stack[s->top];
}






void main()
{
	char op,str[30];//op是表示符号，str来存储获得的计算式
	int i,j,s,n,m,ptr;
	
    char opo,opo1;//两个变量都是来提取栈中符号的
	int s1,s2;//两个变量都是来提取栈中数字的 
	int total;//计算所求的计算式总数
	int string;//计算式长度
	
	
	int y;//来获取所要求的值
	int a;


	stack1 OPTR1,*OPTR=&OPTR1;
	stack2 OPND1,*OPND=&OPND1;//通过定义变量的方式，同时给指针分配内存


	InitStack1(OPTR);
	InitStack2(OPND);//初始化两个栈 


	string=1;//获取字符的个数，从而控制空格的数量

	total=0;

	

	/**********************美化界面***********************/
    	system("color 16");
	system("mode con: cols=50 lines=50");
	/****************************************************/


	/***************通过输入的方式来获取结果**************/
	printf("请输入您要的结果：");
	scanf("%d",&y);
	printf("┏━━━━━━━━━━━━━━━━━━━━━┓\n");
	printf("┃                计算式列表:(每页15)       ┃\n");
	printf("┣━━━┳━━━━━━━━━━━━━━━━━┫\n");
	/******************************************************/

 


	//************************算法开始**********************************************/
	//9个数字8个位置，用八位四制码的方式来表示符号，0无符号，1是‘+’
	//2是‘-’，3是‘*’
	//我们模仿二进制的求法来解决十进制向四进制的转化。因此我们可以用
	//n%d得到的余数做为最低位的四进制码，然后n/4，把它向前演化，得到
	//倒数第二位的四进制码。从而来获取各位的四进制码，所以共有4的8次方种情况。
	//我们求得的四进制码，比如00001023，本来是表示12345+67-8*9，但是为了简便，
	//我们把它倒过来用，最后一位的3来代表第一位符号，即1*2-34+56789，看上去不一样，
	//情况总数是一样的而且不重复。
	//******************************************************************************/

	//****************************解决结果问题**************************************/
	//算式出来了，结果是通过栈来求的，对于符号的优先级问题，我们需要用栈来解决，而在这里的
	//在循环的过程中入栈出栈就存在好多种情况，下面有一一的考虑
	//******************************************************************************/


	for(i=0;i<65536;i++)//四精制数就是65536个
	{
		s=0;
		s1=0;
		s2=0;
		m=1;
		n=i;

		ptr=0;
		str[ptr++]='1';//把1先入数组
		string=1;//来计算表达式长度
		
		for(j=2;j<=9;j++)
		{

			if(n%4)
			{

				//用switch来判断首次进入的是什么符号
				switch(n%4)
				{
				case 1:op='+';break;
				case 2:op='-';break;
				case 3:op='*';break;
				}
				

				//把三个符号都入栈的情况解决掉
				if(Getnum2(OPND)==1&&Gettop1(OPTR)!='*')
				{
					opo=Gettop1(OPTR);
					pop1(OPTR);
					opo1=Gettop1(OPTR);
					pop1(OPTR);
					s1=Gettop2(OPND);
					pop2(OPND);
					s2=Gettop2(OPND);
					pop2(OPND);

					if(opo1=='+')
						s=s2+s1;
					else s=s2-s1;

					push2(OPND,s);
					push1(OPTR,opo);
				}


				//如果栈都为空，那就都入栈
				if(Isnull2(OPND)==1&&Isnull1(OPTR)==1)
				{
				push2(OPND,m);
				push1(OPTR,op);
				}
				
				/******************************************************************/				
				//如果栈都不为空，分成几种情况考虑
				//如果进来的符号是‘*’，则先考虑栈顶符号，也是‘*’的话，先出栈运算
										//如果栈顶符号不是‘*’，则直接不用计算
				//如果进来的符号不是‘*’，同样需要考虑栈顶符号，栈顶为‘*’，先计算，
										//如果不是‘*’，则按栈顶元素的符号来计算。

				//最后在把计算结果和符号如栈

				/******************************************************************/
				else
				{
					if(op=='*')
					{
					
						if(Gettop1(OPTR)=='*')
						{
							s1=Gettop2(OPND);
							s=s1*m;
							pop2(OPND);
							pop1(OPTR);
				
						}
						else
							s=m;
					}
							
					else 
					{
					
						if(Gettop1(OPTR)=='*')
						{
							s1=Gettop2(OPND);
							s=s1*m;
							pop2(OPND);
							pop1(OPTR);
						}
						else if(Gettop1(OPTR)=='+')
						{
							s1=Gettop2(OPND);
							s=s1+m;
							pop2(OPND);
							pop1(OPTR);
						}
						else
						{ 
							s1=Gettop2(OPND);
							s=s1-m;
							pop2(OPND);
							pop1(OPTR);
						}

					}
					push2(OPND,s);
					push1(OPTR,op);
				}
				
			m=j;
			}


			//来判断有无符号和是什么符号
			switch(n%4)
			{
			case 0:m=m*10+j;break;
			case 1:op='+';break;
			case 2:op='-';break;
			case 3:op='*';break;
			}
	

			//存储计算式
			if(n%4) str[ptr++]=op;
			str[ptr++]='0'+j;//数字转化为字符
			string++;
			n/=4;
		} //the end of for(i)
	


		//**********************计算式最后计算**********************/
		//通过循环最后会出现几种情况，1、没有经过循环也就是没有一个符号，
		//2、两个栈都只有一个元素，3、两个栈都有两个元素，
		//通过三种情况的考虑，在联合最后一个m值进行计算
		//*************************************************************/
		
	if(Isnull2(OPND)==1&&Isnull1(OPTR)==1)
		s=m;

	else if(Getnum2(OPND)==0&&Getnum1(OPTR)==0)
	{
		s1=Gettop2(OPND);
		pop2(OPND);
		opo=Gettop1(OPTR);
   		pop1(OPTR);

		if(opo=='*')
			s=s1*m;
		else if(opo=='+')
			s=s1+m;
		else if(opo=='-')
			s=s1-m;
	}
	else if(Getnum2(OPND)==1&&Getnum1(OPTR)==1)
	{
		opo=Gettop1(OPTR);
		pop1(OPTR);
		opo1=Gettop1(OPTR);
		s1=Gettop2(OPND);
		pop2(OPND);
		s2=Gettop2(OPND);
		pop2(OPND);
		if(opo=='*')
		{
			s=s1*m;
			if(opo1=='+')
				s=s+s2;
			else s=s2-s;
		}
		else if(opo=='+')
			if(opo1=='-')
				s=s2-s1+m;
			else s=s1+s2+m;
		else
			if(opo1=='-')
				s=s2-s1-m;
			else s=s1+s2-m;
		
	}

	str[ptr]='\0';
			
	//格式化输出
		if(s==y){
		   total++;
	
			
			printf("┃计算式┃%-20s=%-5d",str,s);
				for(a=1;a<=17-string;a++)//格式化输出
					printf(" ");
				printf("┃\n");
			printf("┣━━━╋━━━━━━━━━━━━━━━━━┫\n");
		
		if(total%15==0&&total!=0)
			{
				printf("┃      ┃    按任意键翻页                  ┃\n");
				printf("┗━━━┻━━━━━━━━━━━━━━━━━┛\n");
				system("pause");
				system("cls");
			}
		}
		
			InitStack2(OPND);
			InitStack1(OPTR);
	
	}//the end of for(j)

	if(total==0)
		printf("┃总计  ┃      该结果无计算式             ┃\n");
	else
		printf("┃总计  ┃       %-5d种算式                ┃\n",total);
	printf("┗━━━┻━━━━━━━━━━━━━━━━━┛\n");
}