栈的应用

 

#include<stdio.h>
#include<stdlib.h>


#define StackSize 100
//栈的顺序存储
typedef int DataType;
typedef struct {
	DataType data[StackSize];
	int top;//栈顶
}
SeqStack;

SeqStack s;
void InitStack(SeqStack* s) {
	s->top = -1;
}
int stackEmpty(SeqStack* s) {
	return s->top == -1;
}
int stackFull(SeqStack* s) {
	return s->top == StackSize - 1;
}
void push(SeqStack* s,DataType x) {
	if (stackFull(s)) {
		printf("");
		return;
	}
	s->data[++	s->top ]= x;
}
DataType pop(SeqStack* s) {
	if (stackEmpty(s)) {
		exit(0);//失败
	}
	else {
		return s->data[s->top--];
	}
}
DataType getTop(SeqStack* s) {
	return s->data[s->top];
}

//是否匹配（）
int Expr() {
	SeqStack s;
	DataType ch, x;
	InitStack(&s);
	ch = getchar();
	while (ch!='\n')
	{
		if (ch == '(')
			push(&s, ch);
		else if (ch == ')')
		{
			if (stackEmpty(&s)) {
				return 0;
			}
			else {
				x=pop(&s);
			}			
		}
		ch = getchar();
	}
	if (stackEmpty(&s)) return 1;
	else return 0;
}
//匹配个数
int Matching( const char str[]) {
	int breakSum = 0,popFlag = 1;
	SeqStack s;
	InitStack(&s);
	int i = 0;
	while (str[i] !='\0')
	{
		if (str[i] == '(') {
			push(&s, str[i]);
		}
		else if (str[i] == ')') {
			if (!stackEmpty(&s)) {			
				pop(&s);
					breakSum++;
			}
			else
			{
				popFlag = 0;
				break;
			}			
		}
		i++;
	}
	if (popFlag&&stackEmpty(&s)) {
		return breakSum;
	}
	return 0;
}

//是否回文
int symmetry(char str[]) {
	SeqStack s;
	int j, k, i = 0;
	InitStack(&s);

	while (str[i]!='\0')
	{
		i++;
	}

	for ( j = 0; j < i/2; j++)
	{
		push(&s, str[j]);
	}
	k = (i + 1) / 2;
	for ( j = k; j <i; j++)
	{
		if (str[j] != pop(&s)) {
			return 0;
		}
	}
	return 1;
}
//转2进制
void conversion(int N, int d) {
	SeqStack S;
	InitStack(&S);
	while (N)
	{
		push(&S,N% d);
		N = N / d;
	}
	while (!stackEmpty(&S))
	{
		printf("%d", pop(&S));
	}
}
//递归
long int fact(int n) {
	int temp;
	if (n == 0) {
		return 1;
	}
	else
	{
		temp = n * fact(n - 1);
	}
r12:return temp;
}
float fu(int n) {
	float f1, f2;
	if (n < 2)
		return (n + 1);
	else
		return fu(n / 2) * fu(n / 4);
}


#define QueueSize 100
typedef struct {
	DataType data[QueueSize];
	int front, rear;
} SeqQueue;
SeqQueue Q;
typedef struct {
	DataType data[QueueSize];
	int front, rear;
} CirQueue;
void initQueue(CirQueue* Q) {
	Q->front = Q->rear = 0;
}
int queueEmpty(CirQueue* Q) {
	return Q->front == Q->rear;
}
int QueueFull(CirQueue* Q) {
	return (Q->rear + 1) % QueueSize == Q->front;
}
void QueueEn(CirQueue* Q, DataType x) {
	if (QueueFull(Q)) {
		exit(0);
	}
	Q->data[Q->rear] = x;
	Q->rear = (Q->rear + 1) % QueueSize;
}
DataType GetFront(CirQueue* Q) {
	if (queueEmpty(Q)) {
		exit(0);
	}
	return Q->data[Q->front];
}

DataType DeQueue(CirQueue* Q) {
	DataType x = Q->data[Q->front];
	Q->front = (Q->front++) % QueueSize;
	return x;
}
void Algo(SeqStack S) {
	int i = 1;
	CirQueue Q; SeqStack T;
	initQueue(&Q);
	InitStack(&T);
	while (!stackEmpty(&S))
	{
		if (i % 2 != 0)
			push(&T, pop(&S));
		else
		{
			QueueEn(&Q, pop(&S));
		}
		i++;
	}
	while (!queueEmpty(&Q))
	{
		push(&S, DeQueue(&Q));
	}
	while (!stackEmpty(&T))
	{
		push(&S, pop(&T));
	}
}


int main() {
	//char str[] = "abvba";	
	//int x1 = symmetry(str);
	//int x1 = Expr();
	//printf("%d",x1); 	 
	char str[]="(1 + (3 + 4) * 2))";
	printf("%d",Matching(str));

	
	conversion(9, 2);
	/*long int n;
	n = fact(5);
rl1:printf("5!=%ld", n);
	printf("fu()=%f\n", fu(10));*/
}