21 专硕

中缀表达式转后缀表达式的算法
思路：利用栈，需要对运算符设置优先级，乘除优先级最高，加减次之，左括号最低。如果是操作数，直接输出，如果是操作符，则需要判断。
当栈为空时，操作符直接入栈。
若不为空，左括号直接入栈，是右括号，则栈顶元素一直出栈，直到匹配到左括号。若不是括号，则判断操作符优先级，若栈顶元素优先级大于等于该运算符，则需要出栈直到栈顶元素优先级小于当前元素，然后把当前运算符入栈。最后，如果栈不为空，则弹出所有元素并输出。

int prio(char op) {                 //给运算符优先级排序
    int priority;
    if (op == '*' || op == '/')
        priority=2;
    if (op == '+' || op == '-')
        priority=1;
    if (op == '(')
        priority=0;
    return priority;
}
int len(char *str)
{
	int i=0;
	while(str[i]!='\0')
	{
		i++;
	}
	return i;
}
bool Trans(char *str,char *str1) {   //引用传递
	char s[maxsize];                //定义一个char类型的栈s
    int i,top=-1,k=0;
    for (i = 0; i<len(str); i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {    //如果是操作数，直接输出
            str1[k++]=str[i];
        }
        else {                        //否则是操作符
            if (top==-1)            //栈空则入站
                s[++top]=str[i];
            else if (str[i] == '(')   //左括号入栈
                s[++top]=str[i];
            else if (str[i] == ')') {  //如果是右括号，只要栈顶不是左括号，就弹出并输出
                while (s[top] != '(') {  
                    str1[k++]= s[top--];
                }
                top--;                 //弹出左括号，但不输出
            }
            else {
                while (prio(str[i]) <= prio(s[top])) { //栈顶优先级大于等于当前运算符，则输出
                    str1[k++]= s[top--];
                    
                    if (top==-1)      //栈为空，停止
                        break;
                }
                s[++top]=str[i];   //把当前运算符入栈
            }
        }
    }
    while (top>=0) {      //最后，如果栈不空，则弹出所有元素并输出
       str1[k++]= s[top--];
        
    }
	str1[k]='\0';//加结束符
    return true;
}
int main() {                //主程序
	char infix[maxsize]="a+b*c+(d*e+f)*g";
	char postfix[maxsize];
    Trans(infix,postfix);	
	printf("%s",postfix);
    return 0;
}

一个二维数组，每一行存放一个字符串，比较字符串并排序

void sort(char a[maxsize][maxsize],int n)
{
	for(int i=0;i<n-1;i++) //冒泡排序
		for(int j=0;j<n-i-1;j++)
			if(strcmp(a[j],a[j+1])>0)
			{
				char *temp=(char *)malloc(sizeof(char)*maxsize);
				strcpy(temp,a[j]);
				strcpy(a[j],a[j+1]);
				strcpy(a[j+1],temp);
			}
}

一行n个框，三个颜色，每个相邻的框颜色不能相同，用递归写出有多少种方法。

int f(int n) //n个框的总方案
{
	if(n==1)
		return 3;
	else
		return 2*f(n-1);  //对于n-1个格子的每一种情况，第n个各自都有2种可用的颜色。
}

定义结构体，链表输入学生数据，再输入到文件中。

typedef struct student
{
	char sex[10];
	char name[10];
	int age;
	struct student *next;
}*student;
void build_list(student head) //建立链表输入学生数据
{
	student q=head;
	student p=(student)malloc(sizeof(struct student));
	while(scanf("%s %s %d",p->sex,p->name,p->age)!=EOF)
	{
		q->next=p;
		q=p;
		student p=(student)malloc(sizeof(struct student));
	}
	q->next=NULL;//建立链表尾
}
void ListToFile(student head) //将学生数据从链表输入到文件
{
	FILE *fp=fopen("student.txt","w");
	if(fp==NULL)
		return;
	student p=head;
	while(p!=NULL)
	{
		fprintf(fp,"%s %s %d",p->sex,p->name,p->age);
		p=p->next;
	}
	fclose(fp);
}

将该链表按性别拆分为两个链表并排序，再写到两个文件中。

void sort(student head)
{
	student p,pre,tail;
	tail=NULL;
	while(head->next!=tail)
	{
		pre=head;
		p=head->next;
		while(p->next!=tail)
		{
			if(p->age>p->next->age)
			{
				pre->next=p->next;
				p->next=p->next->next;
				pre->next->next=p;
			}
			else
				p=p->next;
			pre=pre->next;
		}
		tail=p;
	}
}
void divide(student head)
{
	student list1=(student)malloc(sizeof(struct student));
	student list2=(student)malloc(sizeof(struct student));
	student p=head->next,l1=list1,l2=list2;  //l1,l2分别是list1,list2的尾指针
	while(p!=NULL)
	{
		if(strcmp(p->sex,"man")==0)
		{
			l1->next=p;
			l1=p;
		}
		else 
		{
			l2->next=p;
			l2=p;
		}
		p=p->next;
	}
	l1->next=NULL;
	l2->next=NULL;
	sort(list1);
	sort(list2);
	FILE *fp1=fopen("man.txt","w");
	FILE *fp2=fopen("woman.txt","w");
	l1=list1->next;
	l2=list2->next;
	while(l1!=NULL)
	{
		fprintf(fp1,"%s %s %d",l1->sex,l1->name,l1->age);
		l1=l1->next;
	}
	while(l2!=NULL)
	{
		fprintf(fp2,"%s %s %d",l2->sex,l2->name,l2->age);
		l2=l2->next;
	}
	fclose(fp1);
	fclose(fp2);
}