1. 用队列实现栈
题目链接
思路:
一个队列放数据,一个队列为空(为了导队列数据),每次删除的时候交换两个队列的功能。
入栈功能:只往非空队列入数据,第一次入数据,随便入哪个队列,因为都是空队列
出栈功能:有数据的队列持续导入到空队列(取队头数据导入,出队删除本身的数据),直到最后一个数据,再将其输出后删除,这样实现了后进先出,此时就完成了刚才交换两个列队功能
取栈顶数据:有数据的队列最后一个数据就是栈顶,通过队列的特性,直接返回队尾数据即可
栈是否为空:两个队列为空,就返回true
,不是就返回false
销毁:除了防止内存泄漏,我们需要把开辟了空间的地方都还回内存中,先free里层结构,在free外层结构
这里说明代码这个部分
修改结构体成员,需要传地址,运算符的优先级是先->
,后&
所以是先找到结构体里面的成员变量,在取里面它的地址,就可以通过函数修改
2. 用栈实现队列
题目链接
思路:
一个栈用来入数据(pushST),一个栈用来出数据(popST),popST为空,就让pushST导数据进来。
入队:往专门用来入数据的栈(pushST),插入数据
出栈:popST没有数据就让pushST把数据导出来(出栈),所以先进去的数据会在pushST栈的栈顶,直接出栈就实现了先进先出
获取队头数据:popST的栈顶就是队头数据
销毁:和上一题一样,先销毁里层结构,在销毁外层结构,否则内存泄漏
注意只有在popST为空时候才能导数据,插入数据也只能在pushST,不然顺序就会被打乱
3. 队列实现栈源代码:
typedef int QDataType;
// 定义队列的单个节点
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QueueNode;
// 定义队列
// 队列里面有头和尾结点,头和尾结点的类型是单个节点的结构
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
// 初始化
void QueueInit(Queue* pq);
// 判断队列是否为空
bool QueueEmpty(Queue* pq);
// 入队
void QueuePush(Queue* pq, QDataType x);
// 出队
void QueuePop(Queue* pq);
// 获取队头数据
QDataType QueueFront(Queue* pq);
// 获取队尾数据
QDataType QueueBack(Queue* pq);
// 获取队列数据个数
int QueueSize(Queue* pq);
// 销毁
void QueueDestroy(Queue* pq);
// 初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = NULL;
pq->tail = NULL;
}
// 判断队列是否为空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
// 入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
// 创建新节点
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
assert(newNode);
newNode->data = x;
newNode->next = NULL;
// 插入数据分两种情况
// 1. 队列为空:头和尾赋值为新节点
// 2. 队列不为空:直接尾插,在更新尾结点
if (pq->head == NULL)
{
pq->head = pq->tail = newNode;
}
else
{
pq->tail->next = newNode;
pq->tail = newNode;
}
}
// 出队
void QueuePop(Queue* pq)
{
assert(pq);
// 空队列不能删除
assert(!QueueEmpty(pq));
// 头删
QueueNode* headNext = pq->head->next;
free(pq->head);
pq->head = headNext;
// 头为空表示队列空了,因为上面的步骤只把头给置空,尾没有,tail就是野指针了
if (pq->head == NULL)
pq->tail = NULL;
}
// 获取队头数据
QDataType QueueFront(Queue* pq)
{
assert(pq);
// 空队列不能获取数据
assert(!QueueEmpty(pq));
return pq->head->data;
}
// 获取队尾数据
QDataType QueueBack(Queue* pq)
{
assert(pq);
// 空队列不能获取数据
assert(!QueueEmpty(pq));
return pq->tail->data;
}
// 获取队列数据个数
int QueueSize(Queue* pq)
{
assert(pq);
int size = 0;
QueueNode* cur = pq->head;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
// 销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
// 通过申请空间或全局、静态变量就不会野指针
// 经典野指针:
// MyStack* st;
// return &st;
MyStack* st = (MyStack*)malloc(sizeof(MyStack));
// 修改结构体成员,需要传地址,运算符的优先级是先->,在&
// 所以是先找到结构体里面的成员变量,在取里面它的地址,就可以通过函数修改
QueueInit(&st->q1);
QueueInit(&st->q2);
return st;
}
void myStackPush(MyStack* obj, int x) {
// 向非空的队列插入数据
if (!QueueEmpty(&obj->q1))
QueuePush(&obj->q1, x);
else
QueuePush(&obj->q2, x);
}
int myStackPop(MyStack* obj) {
// 确定空队列和非空队列
MyStack* emptyQ = &obj->q1;
MyStack* noemptyQ = &obj->q2;
if (QueueEmpty(noemptyQ))
{
emptyQ = &obj->q2;
noemptyQ = &obj->q1;
}
// 非空队列除最后一个数据以外,其他数据全部导到空队列
while (QueueSize(noemptyQ) > 1)
{
QueuePush(emptyQ, QueueFront(noemptyQ));
QueuePop(noemptyQ);
}
// 非空队列的最后一个数据就是栈顶,所以就出栈
int top = QueueFront(noemptyQ);
QueuePop(noemptyQ);
return top;
}
int myStackTop(MyStack* obj) {
// 非空队列的最后一个数据就是栈顶,取最后一个数据就是top
if (!QueueEmpty(&obj->q1))
return QueueBack(&obj->q1);
else
return QueueBack(&obj->q2);
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
// 先销毁里层
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
// 后销毁外层
free(obj);
}
/**
* Your MyStack struct will be instantiated and called as such:
* MyStack* obj = myStackCreate();
* myStackPush(obj, x);
* int param_2 = myStackPop(obj);
* int param_3 = myStackTop(obj);
* bool param_4 = myStackEmpty(obj);
* myStackFree(obj);
*/
4. 队列实现栈源代码:
typedef int STDataType;
typedef struct Stack
{
STDataType* a; // 数组地址
int top; // 数据个数
int capacity; // 容量
}Stack;
// 初始化
void StackInit(Stack* ps);
// 栈为空判断
bool StackEmpty(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType x);
// 出栈
void StackPop(Stack* ps);
// 取栈顶元素
STDataType StackTop(Stack* ps);
// 栈的大小
int StackSize(Stack* ps);
// 销毁
void StackDestroy(Stack* ps);
// 初始化
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
// 栈为空判断
bool StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
// 入栈
void StackPush(Stack* ps, STDataType x)
{
assert(ps);
// 栈容量检查
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
assert(tmp);
ps->a = tmp;
ps->capacity = newCapacity;
}
// 插入数据
ps->a[ps->top] = x;
ps->top++;
}
// 出栈
void StackPop(Stack* ps)
{
assert(ps);
// 空栈不能出
assert(!StackEmpty(ps));
ps->top--;
}
// 取栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps);
// 空栈不能取
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
// 栈的大小
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
// 销毁
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
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) {
// 只往pushST插入数据
StackPush(&obj->pushST, x);
}
// 把pushST的数据导入popST
void StackDataMove(MyQueue* obj)
{
while (StackSize(&obj->pushST))
{
StackPush(&obj->popST, StackTop(&obj->pushST));
StackPop(&obj->pushST);
}
}
int myQueuePop(MyQueue* obj) {
// popST为空,就把pushST数据全部导入进来
if (StackEmpty(&obj->popST))
StackDataMove(obj);
// 出队
int front = StackTop(&obj->popST);
StackPop(&obj->popST);
return front;
}
int myQueuePeek(MyQueue* obj) {
// popST为空,就把pushST数据全部导入进来
if (StackEmpty(&obj->popST))
StackDataMove(obj);
int front = StackTop(&obj->popST);
return front;
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}
void myQueueFree(MyQueue* obj) {
// 先销毁里层
StackDestroy(&obj->pushST);
StackDestroy(&obj->popST);
// 后销毁外层
free(obj);
}
/**
* Your MyQueue struct will be instantiated and called as such:
* MyQueue* obj = myQueueCreate();
* myQueuePush(obj, x);
* int param_2 = myQueuePop(obj);
* int param_3 = myQueuePeek(obj);
* bool param_4 = myQueueEmpty(obj);
* myQueueFree(obj);
*/