数据结构——括号匹配问题、队列实现栈、栈实现队列、循环队列的设计

括号匹配问题

bool isValid(char * s) {
 static char map[][2] = { {'(',')'},{'[',']'},{'{','}' } };
 Stack st;
 stackInit(&st, 10);
 while (*s)
 {
  int i = 0;
  int flag = 0;
  for (; i < 3; i++)
  {
   if (*s == map[i][0])
   {
    stackPush(&st, *s);
    ++s;
    flag = 1;
    break;
   }
  }
   if (flag == 0)
  {
   if (stackEmpty(&st))
    return false;
   char topChar = stackTop(&st);
   int j = 0;
   for (; j < 3;j++)
   {
    if (*s == map[j][1])
    {
     if (topChar == map[j][0])
     {
      stackPop(&st);
      ++s;
      break;
     }
     else
      return false;
    }
   }
  }
 }
  if (stackEmpty(&st))
  return true;
 return false;
}

用队列实现栈

typedef struct {
 Queue* q;
} MyStack;

MyStack* myStackCreate() {
 MyStack* ms = (MyStack*)malloc(sizeof(MyStack));
 queueInit(&ms->q);
 return ms;
}

void myStackPush(MyStack* obj, int x) {
 queuePush(&obj->q, x);
}

int myStackPop(MyStack* obj) {
 int ret;
 int size = queueSize(&obj->q);
 while (size > 1)
 {
  int front = queueFront(&obj->q);
  queuePop(&obj->q);
  queuePush(&obj->q, front);
  --size;
 }
 ret = queueFront(&obj->q);
 queuePop(&obj->q);
 return ret;
}

int myStackTop(MyStack* obj) {
 return queueBack(&obj->q);
}

bool myStackEmpty(MyStack* obj) {
 return queueEmpty(&obj->q);
}
void myStackFree(MyStack* obj) {
 queueDestroy(&obj->q);
 free(obj);
}

用栈实现队列

typedef struct {
 Stack pushST;
 Stack popST;
} MyQueue;

MyQueue* myQueueCreate() {
 MyQueue* mq = (MyQueue*)malloc(sizeof(MyQueue));
 stackInit(&mq->popST, 10);
 stackInit(&mq->pushST, 10);
 return mq;
}

void myQueuePush(MyQueue* obj, int x) {
 stackPush(&obj->pushST, x);
}

int myQueuePop(MyQueue* obj) {
 int ret;
 if (stackEmpty(&obj->popST))
 {
  while (stackEmpty(&obj->pushST) != 1)
  {
   int top = stackTop(&obj->pushST);
   stackPop(&obj->pushST);
   stackPush(&obj->popST, top);
  }
 }
 ret = stackTop(&obj->popST);
 stackPop(&obj->popST);
 return ret;
}

int myQueuePeek(MyQueue* obj) {
 if (stackEmpty(&obj->popST))
 {
  while (stackEmpty(&obj->pushST) != 1)
  {
   int top = stackTop(&obj->pushST);
   stackPop(&obj->pushST);
   stackPush(&obj->popST, top);
  }
 }
 return stackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
 return stackEmpty(&obj->popST) && stackEmpty(&obj->pushST);
}
void myQueueFree(MyQueue* obj) {
 stackDestory(&obj->popST);
 stackDestory(&obj->pushST);
 free(obj);
}

设计循环队列

typedef struct {
 int front;
 int rear;
 int size;
 int k;
 int* array;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
 MyCircularQueue* mq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
 int* arrat = (int*)malloc(sizeof(int)*k);
 mq->front = mq->rear = 0;
 int size = 0;
 int k = k;
 return mq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
 if (obj->size==obj->k)
  return false;
 obj->array[obj->rear++] = value;
 if (obj->rear == obj->k)
  obj->rear = 0;
 obj->size++;
 return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
 if (obj->size == 0)
  return false;
 obj->front++;
 if (obj->front == obj->k)
  obj->front = 0;
 obj->size--;
 return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
 if (obj->size == 0)
  return -1;
 return obj->array[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
 if (obj->size == 0)
  return -1;
 if (obj->rear == 0)
  return obj->array[obj->k - 1];
 return obj->array[obj->rear - 1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
 if (obj->size == 0)
  return true;
 return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
 if (obj->size == obj->k)
  return true;
 return false;
}
void myCircularQueueFree(MyCircularQueue* obj) {
 free(obj->array);
 free(obj);
}