#include<stdio.h>
#include <stdlib.h>
#include <math.h>
#define SIZE  50
#define ADD 20
typedef char ElemType ;
typedef struct node{
     ElemType  *base;
     ElemType  *top;
     int stacksize;
}stack;

void initstack (stack *s)
{
    s->base=(ElemType*)malloc (SIZE* sizeof(ElemType));
    if ( !s->base )
    {
        exit(0);
    }
    s->top=s->base;
    s->stacksize=SIZE;
}

void push(stack *s,ElemType e)
{
    if(s->top-s->base >= s->stacksize)
    {
        s->base=(ElemType *)realloc(s->base,(s->stacksize+ADD)*
    sizeof    (ElemType));
    if(!s->base)
    {
        exit (0);
    }
    }
    *s->top++=e;
}
void pop (stack*s,ElemType *e)
{
    if(s->base ==s->top)
      {
          return;
      }
      *e=*--(s->top);
}
void empty(stack *s)
{
    if(s->top==s->base)
    return 1;
    return 0;
}
void stacksize1(stack s)
{
    return (s.top-s.base);
}
int main()
{
    stack s;
    char ch;
    initstack(&s);
    scanf("%c",&ch);
    while(ch!='\n')
    {
        if(ch=='I'||ch=='i')
          push(&s,ch);
        if(ch=='o'||ch=='O')
        {
           if(empty (&s))
           {
               printf("false");
               break;
           }
           else{
               pop(&s,&ch);
           }
        }
        scanf("%d",&ch);
    }
    if(empty(&s))
    {
        printf("true");
    }
    else{
        printf("false");
    }
    return 0;
}

你的程序看着头晕，找了个前几天学习的代码给你参考。

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


typedef int Item;

typedef struct Node
{
    Item item;
    struct Node * pNext;
}NODE, *PNODE;

typedef struct Stack
{
    PNODE pTop;
    PNODE pBottom;
} STACK, *PSTACK;

void init(PSTACK pS);
void push(PSTACK ps, Item item);
void traverse(PSTACK ps);
int pop(PSTACK pS, Item * item);
void clear(PSTACK pS);
int empty( PSTACK pS);


int main()
{
    ....
}

void init(PSTACK pS)
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if(NULL == pS->pTop)
    {
        fprintf(stderr, "内存分配失败！");
        exit(-1);
    }
    pS->pTop->pNext = NULL;
    pS->pBottom = pS->pTop;    
}

void push(PSTACK pS, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));

    pNew->item = val;
    pNew->pNext = pS->pTop;
    pS->pTop = pNew;
}

void traverse(PSTACK pS)
{
    PNODE p = pS->pTop;
    while (p != pS->pBottom)
    {
        printf("%d ", p->item);
        p = p->pNext;
    }
    printf("\n");
}

int empty(PSTACK pS)
{
    if(pS->pTop == pS->pBottom)
        return 1;
    else
        return 0;
}

int pop(PSTACK pS, int * pVal)
{
    if ( empty(pS) )
    {
        return 0;
    }
    else
    {
        PNODE r = pS->pTop;
        *pVal = r->item;
        pS->pTop = r->pNext;
        free(r);
        r = NULL;

        return 1;
    }
}

void clear(PSTACK pS)
{
    if (empty(pS))
    {
        return;
    }
    else
    {
        PNODE p = pS->pTop;
        PNODE q = NULL;

        while (p != pS->pBottom)
        {
            q = p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pBottom;
    }
}