栈相关试题

1.向一个栈顶指针为top的链栈中插入一个x结点，则执行()
A.top->next=x
B. x->next=top- > next; top->next=x
C.x- >next=top; top=x
D.x- >next=top，top=top- >next

2.链栈执行Pop操作，并将出栈的元素存在x中，应该执行( )。
A.x=top; top=top->next
B. x=top- >data
C.top=top- >next ;x=top->data
D.x=top->data;top=top->next

3.假设以I和O分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，可以操作的序列称为合法序列，否则称为非法序列。
1)下面所示的序列中哪些是合法的?.
A. IOIIOIOO
B. IOOIOIIO
C. IIIOIOIO
D. IIOOIOO
2)通过对1)的分析，写出一个算法，判定所给的操作序列是否合法。若合法,返回true,否则返回false (假定被判定的操作序列已存入一维数组中)。
答案：

1. A、D合法，而B、C不合法。在B中，先入栈1次，再连续出栈2次，错误。在C中，入栈和出栈次数不一致，会导致最终的栈不空。A、D均为合法序列注意:在操作过程中，入栈次数一定 大于等于出栈次数;结束时，栈一定为空。
   2）算法的基本设计思想：依次逐一扫描入栈出栈序列，每扫描至任何一个位置均需要检查出栈次数是否小于入栈次数，若大于则为非法序列。扫描结束后，再判断入栈和出栈的次数是否相等，若不想等则不合题意，为非法序列。
   代码如下：
   方法①

bool Judge(char A[]){
	int i=0;
	int j=k=0;
	while(A[i]!='\0'){
		switch(A[i]){
			case "I":j++;break;
			case "O":k++;
			if(k>j){printf("序列非法\n"); exit(0);}
		}
		i++;
	}
	if(j!=k){
		printf("序列非法\n");
		return false;
	}
	else{
		printf("序列合法\n");
		return true; 
	}
}

方法②

void Judge(char a[]){
	int count=0;
	int m=0;
	int n=0;
	int i=0;
	while(a[i]!='\0'){
		if(a[i]=='I'){
			m++;
			count++;
		}
		else if(a[i]=='O'){
			n++;
			count--;
		}
		if(n>m){
			printf("序列不合法\n");
			return;
		}
		i++;
	}
	if(count==0) printf("序列合法\n");
	else printf("序列不合法\n");
}

4.设单链表的表头指针为L，结点结构由data和next两个域构成，其中data域为字符型。试设计算法判断该链表的全部n个字符是否中心对称。例如xyx、xyyx 都是中心对称。

算法思想：
使用栈来判断链表中的数据是否中心对称。让链表的前一半元素依次
进栈。再处理链表的后一半元素时，当访问倒链表的一个元素后，就
从栈中弹出一个元素，两个元素比较 ，若相等，则将链表的下一个
元素与栈中再弹出的元素比较，直至链表到尾。这是若是空栈，则得出
链表中心对称的结论；否则，当链表中的一个元素与栈中弹出元素不等
时，结论为链表非中心对称，结束算法的执行
代码：

/*算法思想： 
使用栈来判断链表中的数据是否中心对称。让链表的前一半元素依次
进栈。再处理链表的后一半元素时，当访问倒链表的一个元素后，就
从栈中弹出一个元素，两个元素比较 ，若相等，则将链表的下一个
元素与栈中再弹出的元素比较，直至链表到尾。这是若是空栈，则得出
链表中心对称的结论；否则，当链表中的一个元素与栈中弹出元素不等
时，结论为链表非中心对称，结束算法的执行*/
int dc(LinkList L,int n){
	//L是带头结点的n个元素单链表，本算法判断链表是否中心对称
	int i;
	char s[n/2];
	p=L->next;
	for(i=0;i<n/2;i++){
		s[i]=p->data;
		p=p->next;
	} 
	i--;
	if(n%2!=0)p=p->next;
	while(p!=NULL&&s[i]==p->data){
		i--;
		p=p->next;
	}
	if(i==-1)return 1;
	else return 0;
}

5.设有两个栈s1、s2都采用顺序栈方式，并共享一个存储区[0,-maxsize-1]，为了尽量利用空间，减少溢出的可能，可采用栈顶相向、迎面增长的存储方式。试设计s1、s2有关入栈和出栈的操作算法。

两个栈共享向量空间，将两个栈的栈底设在向量两端，初始时，s1
栈指针为-1，s2栈顶指针为maxsize。两个栈顶指针相邻时为栈满。
两个栈顶相向、迎面增长，栈顶指针指向栈顶元素

/*两个栈共享向量空间，将两个栈的栈底设在向量两端，初始时，s1
栈指针为-1，s2栈顶指针为maxsize。两个栈顶指针相邻时为栈满。
两个栈顶相向、迎面增长，栈顶指针指向栈顶元素*/
#define maxsize 100
#define elemtp int
typedef struct{
	elemtp stack[maxsize];
	int top[2];
}stk;
stk s; 

（1）入栈操作

int push(int i,elemtp x){
	//i为栈号，i=0表示左边的栈s1，i=1表示右边的栈s2，x是入栈元素
	//入栈成功返回1，否则返回0
	if(i<0||i>1){
		printf("栈号输入不对");exit(0);
	} 
	if(s.top[1]-s.top[0]==1){
		printf("栈已满\n");
		return 0;
	}
	switch(i){
		case 0:s.stack[++s.top[0]]=x;return 1;break;
		case 1:s.stack[--s.top[1]]=x;return 1;break;
	}
}

(2)出栈操作

//出栈操作
elemtp pop(int i){
	//i代表栈号
	//退栈成功返回退栈元素，否则返回-1
	if(i<0||i>1){
		printf("栈号输入错误\n");exit(0);
	} 
	switch(i){
		case 0:
			if(s.top[0]==-1){
				printf("栈空\n");
				return -1; 
			}
			else{
				return s.stack[s.top[0]--];
			}
		case 1:
			if(s.top[1]==maxsize){
				printf("栈空\n");
				return -1; 
			}
			else return s.stack[s.top[1]++];
	}
}