用栈实现队列
typedef int DataT;
typedef struct Stack
{
int* a;
int top;
int capacity;
}Stack;
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (int *)malloc(sizeof(DataT)*4);
pst->top = 0;
pst->capacity = 4;
}
void StackDestroy(Stack* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = pst->capacity = 0;
}
void StackPush(Stack* pst,DataT x)
{
assert(pst);
if (pst->top == pst->capacity)
{
pst->capacity *= 2;
DataT* tmp = (DataT*)realloc(pst->a, sizeof(DataT) * pst->capacity);
if (tmp == NULL)
{
printf("内存不足\n");
exit(-1);
}
else
{
pst->a = tmp;
}
}
pst->a[pst->top] = x;
pst->top++;
}
void StackPop(Stack* pst)
{
assert(pst);
assert(pst->top > 0);
--pst->top;
}
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
int StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0 ? 1 : 0;
}
DataT StackTop(Stack* pst)
{
assert(pst);
assert(pst->top > 0);
return pst->a[pst->top - 1];
}
typedef struct
{
Stack pushSt;
Stack popSt;
} MyQueue;
MyQueue* myQueueCreate()
{
MyQueue*q=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->pushSt);
StackInit(&q->popSt);
return q;
}
void myQueuePush(MyQueue* obj, int x)
{
StackPush(&obj->pushSt,x);
}
int myQueuePop(MyQueue* obj)
{
int frist=myQueuePeek(obj);
StackPop(&obj->popSt);
return frist;
}
int myQueuePeek(MyQueue* obj)
{
if(!StackEmpty(&obj->popSt))
{
return StackTop(&obj->popSt);
}
else
{
while(!StackEmpty(&obj->pushSt))
{
StackPush(&obj->popSt,StackTop(&obj->pushSt));
StackPop(&obj->pushSt);
}
return StackTop(&obj->popSt);
}
}
bool myQueueEmpty(MyQueue* obj)
{
return StackEmpty(&obj->popSt)&&StackEmpty(&obj->pushSt);
}
void myQueueFree(MyQueue* obj)
{
StackDestroy(&obj->popSt);
StackDestroy(&obj->pushSt);
free(obj);
}
用队列实现栈
typedef int DataT;
typedef struct QueneNode
{
struct QueneNode* next;
DataT val;
}QueneNode;
typedef struct Quene
{
QueneNode* head;
QueneNode* tail;
}Quene;
int QueneSize(Quene* pq)
{
assert(pq);
int size = 0;
QueneNode* cur = pq->head;
while (cur)
{
++size;
cur = cur->next;
}
return size;
}
void QueneInit(Quene* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
void QueneDestory(Quene* pq)
{
QueneNode* cur = pq->head;
while (cur)
{
QueneNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
void QuenePush(Quene* pq, DataT x)
{
assert(pq);
QueneNode* NewNode = (QueneNode*)malloc(sizeof(QueneNode));
if (NewNode == NULL)
{
printf("内存不足\n");
exit(-1);
}
NewNode->val = x;
NewNode->next = NULL;
if (pq->head == NULL)
{
pq->head = pq->tail = NewNode;
}
else
{
pq->tail->next = NewNode;
pq->tail = NewNode;
}
}
void QuenePop(Quene* pq)
{
assert(pq);
assert(pq->head);
QueneNode* next = pq->head->next;
free(pq->head);
pq->head = next;
if (pq->head == NULL)
{
pq->tail = NULL;
}
}
DataT QueneFront(Quene* pq)
{
assert(pq);
assert(pq->head);
return pq->head->val;
}
DataT QueneBack(Quene* pq)
{
assert(pq);
assert(pq->head);
return pq->tail->val;
}
int QueneEmpty(Quene* pq)
{
assert(pq);
return pq->head == NULL ? 1 : 0;
}
typedef struct
{
Quene q1;
Quene q2;
} MyStack;
MyStack* myStackCreate()
{
MyStack*st=(MyStack*)malloc(sizeof(MyStack));
QueneInit(&st->q1);
QueneInit(&st->q2);
return st;
}
void myStackPush(MyStack* obj, int x)
{
if(!QueneEmpty(&obj->q1))
{
QuenePush(&obj->q1,x);
}
else
{
QuenePush(&obj->q2,x);
}
}
int myStackPop(MyStack* obj)
{
Quene*Empty=&obj->q1;
Quene*NoEmpty=&obj->q2;
if(QueneEmpty(&obj->q2))
{
Empty=&obj->q2;
NoEmpty=&obj->q1;
}
while(QueneSize(NoEmpty)>1)
{
QuenePush(Empty,QueneFront(NoEmpty));
QuenePop(NoEmpty);
}
int top=QueneFront(NoEmpty);
QuenePop(NoEmpty);
return top;
}
int myStackTop(MyStack* obj)
{
if(!QueneEmpty(&obj->q1))
{
return QueneBack(&obj->q1);
}
else
{
return QueneBack(&obj->q2);
}
}
bool myStackEmpty(MyStack* obj)
{
return QueneEmpty(&obj->q1)&&QueneEmpty(&obj->q2);
}
void myStackFree(MyStack* obj)
{
QueneDestory(&obj->q1);
QueneDestory(&obj->q2);
free(obj);
}