◆3.17③ 试写一个算法，识别依次读入的一个以@
为结束符的字符序列是否为形如’序列1&序列2′模式
的字符序列。其中序列1和序列2中都不含字符’&'，
且序列2是序列1的逆序列。例如，’a+b&b+a’是属该
模式的字符序列，而’1+3&3-1′则不是。
实现下列函数:
Status match(char *str);
/* 若str是属该模式的字符序列，*/
/* 则返回TRUE，否则返回FALSE */
Stack是一个已实现的栈。
可使用的相关类型和函数：
typedef char SElemType; // 栈Stack的元素类型
Status InitStack(Stack &s);
Status Push(Stack &s, SElemType e);
Status Pop(Stack &s, SElemType &e);
Status StackEmpty(Stack s);
Status GetTop(Stack s, SElemType &e);
Status match(char *str) /* 若str是属该模式的字符序列，*/ /* 则返回TRUE，否则返回FALSE */ { //文档没有说明字符串是以@结尾的 //也没有说栈的类型是SqStack，用Stack时编译出错 SqStack s; SElemType c; Status flag=1; InitStack(s); char *cur=str; while('&'!=*cur){ Push(s,*cur); ++cur; } //入栈 ++cur; if(!GetTop(s,c)&&*cur!='@'){flag=0;}//判断栈空 while(*cur!='@' ){ Pop(s,c); if(c!=*cur){flag=0;break;} ++cur; }//依次出栈匹配 if(GetTop(s,c)){flag=0;}//再次判断是否非空 return flag; }
3.18② 试写一个判别表达式中开、闭括号是否配对出现的算法。
实现下列函数：
Status MatchCheck(SqList exp);
/* 顺序表exp表示表达式； */
/* 若exp中的括号配对，则返回TRUE，否则返回FALSE */
/* 注：本函数不使用栈 */
顺序表类型定义如下：
typedef struct {
ElemType *elem;
int length;
int listsize;
} SqList; // 顺序表
Status MatchCheck(SqList exp) /* 顺序表exp表示表达式； */ /* 若exp中的括号配对，则返回TRUE，否则返回FALSE */ /* 注：本函数不使用栈 */ /*****************************/ // 此题top指针和cur指针要很仔细地运用，还有判错条件也要小心 { ElemType *cur,*top,*base; base=exp.elem;//模拟栈底 top=cur=base+1;//模拟栈顶(top)和当前元素(cur) if(')'==*cur){ return FALSE; } //判断第一个字符是否为右括号 if(0==exp.length){ return TRUE; }//判断是否为空顺序表 while(cur<=base+exp.length-1){//依次遍历 if('('==*cur){//当元素为左括号时 if(top!=cur){ *top=*cur; *cur='0'; } ++top; }//top始终指向第二个元素 //// else if(')'==*cur){ if(top==base){ return FALSE; } if('('==*(top-1)){ *(--top)='0'; *cur='0'; } } //// ++cur; } if('0'==*base){return TRUE;}//此处应为base，而不是top return FALSE; }
◆3.19④ 假设一个算术表达式中可以包含三种括号：圆括号”(” 和
“)”，方括号”["和"]“和花括号”{“和”}”，且这三种括号可按任意的
次序嵌套使用（如：…[…{…}…[…]…]…[…]…(…)…）。编写判别给定表达
式中所含括号是否正确配对出现的算法(已知表达式已存入数据元素
为字符的顺序表中)。
实现下列函数：
Status MatchCheck(SqList exp);
/* 顺序表exp表示表达式； */
/* 若exp中的括号配对，则返回TRUE，否则返回FALSE */
顺序表类型定义如下：
typedef struct {
ElemType *elem;
int length;
int listsize;
} SqList; // 顺序表
Stack是一个已实现的栈。
可使用的相关类型和函数：
typedef char SElemType; // 栈Stack的元素类型
Status InitStack(Stack &s);
Status Push(Stack &s, SElemType e);
Status Pop(Stack &s, SElemType &e);
Status StackEmpty(Stack s);
Status GetTop(Stack s, SElemType &e);
Status MatchCheck(SqList exp) /* 顺序表exp表示表达式； */ /* 若exp中的括号配对，则返回TRUE，否则返回FALSE */ { ElemType *cur=exp.elem; SElemType temp; SqStack s; InitStack(s); if(0==exp.length){return 1;} while(cur<=exp.elem+exp.length-1){ if('['==*cur||'('==*cur||'{'==*cur){ Push(s,*cur); } else{ GetTop(s,temp); if(StackEmpty(s)){//粗心，栈空时返回的是1而不是0 return 0; } else if(']'==*cur&&'['==temp){ Pop(s,temp); } else if(')'==*cur&&'('==temp){ Pop(s,temp); } else if('}'==*cur&&'{'==temp){ Pop(s,temp); } } ++cur; } if(StackEmpty(s))return 1;//粗心，栈空时返回的是1而不是0 return 0; }
3.20③ 假设以二维数组g(1..m,1..n)表示一个图像
区域，g[i,j]表示该区域中点(i,j)所具颜色，其值
为从0到k的整数。编写算法置换点(i0,j0)所在区域
的颜色。约定和(i0,j0)同色的上、下、左、右的邻
接点为同色区域的点。
实现下列函数：
void ChangeColor(GTYPE g, int m, int n,
char c, int i0, int j0);
/* 在g[1..m][1..n]中，将元素g[i0][j0] */
/* 所在的同色区域的颜色置换为颜色c */
表示图像区域的类型定义如下：
typedef char GTYPE[m+1][n+1];
Stack是一个已实现的栈。
可使用的相关类型和函数：
typedef int SElemType; // 栈Stack的元素类型
Status StackInit(Stack &s, int initsize);
Status Push(Stack &s, SElemType e);
Status Pop(Stack &s, SElemType &e);
Status StackEmpty(Stack s);
Status GetTop(Stack s, SElemType &e);
void ChangeColor(GTYPE g, int m, int n, char c, int i0, int j0) /* 在g[1..m][1..n]中，将元素g[i0][j0] */ /* 所在的同色区域的颜色置换为颜色c */ /* 说明：di=1,2,3,4分别为东南西北四个方向，表示的是下一位置在当前位置的哪 个方向！ 因为数组的下标的性质，只要知道di就能够退回到上一个位置， 而如果第一个元素四周都没有同色元素之后（栈空），结束程序 */ { SqStack S; InitStack(S); int x,y,di; char color; if(i0<=0||i0>m||j0<=0||j0>n){ exit(OVERFLOW); } x=i0; y=j0; color=g[x][y]; do{ if(x>0&&y>0&&x<=m&&y<=n&&color==g[x][y]){ di=1;//设置方向为东 g[x][y]=c; Push(S,di); y=y+1;//当前位置切换为东边的元素 } else{ Pop(S,di); switch(di){//当前位置非同色或不合法，设置当前位置为上一位置 （回退） case 1:--y;break; case 2:--x;break; case 3:++y;break; case 4:++x;break; } ++di; if(di<=4){//若di>4，相当于只回退 switch(di){//切换当前位置到下一位置 case 1:++y;break;//东临 case 2:++x;break;//南 case 3:--y;break;//西 case 4:--x;break;//北 } Push(S,di); } } }while(!StackEmpty(S)); }
◆3.21③ 假设表达式由单字母变量和双目四则运
算算符构成。试写一个算法，将一个通常书写形式
且书写正确的表达式转换为逆波兰式。
实现下列函数：
char *RPExpression(char *e);
/* 返回表达式e的逆波兰式 */
Stack是一个已实现的栈。
可使用的相关类型和函数：
typedef char SElemType; // 栈Stack的元素类型
Status InitStack(Stack &s);
Status Push(Stack &s, SElemType e);
Status Pop(Stack &s, SElemType &e);
Status StackEmpty(Stack s);
SElemType Top(Stack s);
char *RPExpression(char *e) /* 返回表达式e的逆波兰式 */ //由于个人水平,折腾了很就才通过 //主要思路如下: //1 建立优先级表,符号表,栈中元素对应符号 //2 依此读取字符,判断是运算符还是数字,如果数字直接入后缀表达式栈, //如果是运算符,则判断与栈顶元素优先级关系,进行响应操作 /* 容易犯错的地方 1 优先级关系不正确 2 当*p优先级低于运算符栈顶时,出栈,但忘了继续比较 3 忘了字符串长度应该为length+1,因为最后'\0' 变量说明 OPTR 运算符栈 rpe 后缀表达式栈 opera 数组为运算符表 list 数组为优先级表 pre_optr 记录运算符栈元素的代表数字 */ { int i=0,j=0,op1,op2,pre=2,count=0; char *p=e,*head,temp,s[100]; Stack OPTR,rpe; int pre_optr[10]; char opera[7]={'+','-','*','/','(',')','#'}; int list[7][7]={{1,1,-1,-1,-1,1,1} ,{1,1,-1,-1,-1,1,1} ,{1,1,1,1,-1,1,1} ,{1,1,1,1,-1,1,1} ,{-1,-1,-1,-1,-1,0,-2} ,{1,1,1,1,-2,1,1} ,{-1,-1,-1,-1,-1,-2,0}}; InitStack(OPTR); InitStack(rpe); while(*p){ //计算出转换后表达式的长度 if('('!=*p&&')'!=*p){ ++count; } ++p; } p=e; Push(OPTR,'#'); pre_optr[j]=6; while(*p){//依此读入字符,进行相应处理 for(i=0;i<7;++i){ if(opera[i]==*p){ break; } } op2=i; if(7==op2){//判断是否为数字 Push(rpe,*p); } else{ op1=pre_optr[j]; pre=list[op1][op2]; if(-2==pre){ return ERROR; } else if(1==pre){//优先级大于*p if(')'!=*p){ while(1==list[op1][op2]){ Pop(OPTR,temp); --j; Push(rpe,temp); op1=pre_optr[j]; } pre_optr[++j]=op2;//记录栈顶符号 Push(OPTR,*p); } else{//如果为右括号 while(Top(OPTR)!='('){ Pop(OPTR,temp); Push(rpe,temp); --j; } Pop(OPTR,temp); --j; } } else if(0==pre){//等于 Pop(OPTR,temp); } else if(-1==pre){//小于 Push(OPTR,*p); pre_optr[++j]=op2;//记录栈顶符号 } } ++p; }//运行到串尾; while(Top(OPTR)!='#'){ Pop(OPTR,temp); Push(rpe,temp); }//符号栈中所有元素出栈----转换完成 while(!StackEmpty(rpe)){//栈元素逆转---- Pop(rpe,temp); Push(OPTR,temp); } p=head=(char *)malloc(count+1); while('#'!=Top(OPTR)){//将栈元素写入字符串 Pop(OPTR,temp); *p=temp; ++p; } *p='\0'; return head; }
3.24③ 试编写如下定义的递归函数的递归算法:
g(m,n) = 0 当m=0,n>=0
g(m,n) = g(m-1,2n)+n 当m>0,n>=0
并根据算法画出求g(5,2)时栈的变化过程。
实现下列函数：
int G(int m, int n) /* if m<0 or n<0 then return -1. */ { if(m<0||n<0){ return -1; } if(0==m){ return 0; } else { return G(m-1,2*n)+n; //刚开始竟然很白痴地写成G(m-1,2n) - -|| } }
3.25④ 试写出求递归函数F(n)的递归算法，
并消除递归：
F(n) = n+1 当n=0
F(n) = nF(n/2) 当n>0
实现下列函数：
int F(int n) /* if n<0 then return -1. */ { if(n<0){ return -1; } if(0==n){ return 1; } else{ return n*F(n/2); } }
◆3.28② 假设以带头结点的循环链表表示队列，并且
只设一个指针指向队尾元素结点(注意不设头指针)，
试编写相应的队列初始化、入队列和出队列的算法。
实现下列函数：
Status InitCLQueue(CLQueue &rear);
Status EnCLQueue(CLQueue &rear, ElemType x);
Status DeCLQueue(CLQueue &rear, ElemType &x);
带头结点循环链队列CLQueue的类型为以下LinkList类型：
typedef struct LNode{
ElemType data;
struct LNode *next;
} LNode, *LinkList;
typedef LinkList CLQueue;
Status InitCLQueue(CLQueue &rear) { rear=(CLQueue)malloc(sizeof(LNode)); if(!rear){ return FALSE; } rear->next=rear; return TRUE; } Status EnCLQueue(CLQueue &rear, ElemType x) { CLQueue head,p; head=rear->next; p=(CLQueue)malloc(sizeof(LNode)); if(!p){ return FALSE; } p->data=x; p->next=head; rear->next=p; rear=p; return OK; } Status DeCLQueue(CLQueue &rear, ElemType &x) { CLQueue head,p; head=rear->next; if(rear==rear->next){//这里粗心了，忘记考虑队列空的情况 return ERROR; } p=head->next; x=p->data; head->next=p->next; free(p); return OK; }
3.29③ 如果希望循环队列中的元素都能得到利用，
则需设置一个标志域tag，并以tag的值为0或1来区
分，尾指针和头指针值相同时的队列状态是”空”还
是”满”。试编写与此结构相应的入队列和出队列的
算法，并从时间和空间角度讨论设标志和不设标志
这两种方法的使用范围（比如，当循环队列容量较
小而队列中每个元素占的空间较多时，那一种方法
较好？）。
实现下列函数：
Status EnCQueue(CTagQueue &Q, QElemType x);
Status DeCQueue(CTagQueue &Q, QElemType &x);
本题的循环队列CTagQueue的类型定义如下：
typedef char QElemType;
typedef struct {
QElemType elem[MAXQSIZE];
int tag;
int front;
int rear;
} CTagQueue;
Status EnCQueue(CTagQueue &Q, QElemType x) { if(Q.tag){ return ERROR; } Q.elem[Q.rear]=x; if(Q.rear==MAXQSIZE-1){ Q.rear=0; } else{ ++Q.rear; } if(Q.rear==Q.front){ Q.tag=1; } return OK; } Status DeCQueue(CTagQueue &Q, QElemType &x) { if(Q.front==Q.rear&&0==Q.tag){ return ERROR; } else{ x=Q.elem[Q.front]; if(Q.front!=MAXQSIZE-1){ ++Q.front; } else{ Q.front=0; } if(Q.front==Q.rear){ Q.tag=0; } } return OK; }
◆3.30② 假设将循环队列定义为：以域变量rear
和length分别指示循环队列中队尾元素的位置和内
含元素的个数。试给出此循环队列的队满条件，并
写出相应的入队列和出队列的算法（在出队列的算
法中要返回队头元素）。
实现下列函数：
Status EnCQueue(CLenQueue &Q, QElemType x);
Status DeCQueue(CLenQueue &Q, QElemType &x);
本题的循环队列CLenQueue的类型定义如下：
typedef char QElemType;
typedef struct {
QElemType elem[MAXQSIZE];
int length;
int rear;
} CLenQueue;
Status EnCQueue(CLenQueue &Q, QElemType x) { if(MAXQSIZE==Q.length){ return ERROR; } if(MAXQSIZE-1!=Q.rear){ ++Q.rear; Q.elem[Q.rear]=x; } else{ Q.rear=0; Q.elem[Q.rear]=x; } ++Q.length; return OK; } Status DeCQueue(CLenQueue &Q, QElemType &x) { if(!Q.length){ return ERROR; } if(Q.rear+1>=Q.length){ x=Q.elem[Q.rear+1-Q.length]; } else{ x=Q.elem[MAXQSIZE-Q.length+Q.rear+1]; } --Q.length; return OK; }
◆3.31③ 假设称正读和反读都相同的字符序列为
“回文”，例如，’abba’和’abcba’是回文，’abcde’
和’ababab’则不是回文。试写一个算法判别读入的
一个以’@'为结束符的字符序列是否是”回文”。
实现下列函数：
Status Palindrome(char *word);
/* 利用栈和队列判定字符序列word是否是回文 */
可使用栈Stack和队列Queue及其下列操作：
Status InitStack(Stack &S);
Status Push(Stack &S, ElemType x);
Status Pop(Stack &S, ElemType &x);
Status StackEmpty(Stack S);
Status InitQueue(Queue &Q);
Status EnQueue(Queue &Q, ElemType x);
Status DeQueue(Queue &Q, ElemType &x);
Status QueueEmpty(Queue Q);
Status Palindrome(char *word) /* 利用栈和队列判定字符序列word是否是回文 */ { Stack S; char temp; InitStack(S); char *p=word,*q=word; while(*p!='@'){ Push(S,*p); ++p; } while(!StackEmpty(S)){ Pop(S,temp); if(temp!=*q){ break; } ++q; } if(StackEmpty(S)){ return TRUE; } return FALSE; }