数据结构与算法系列之习题练习
博客:小怡同学
个人简介:编程小萌新
如果博客对大家有用的话，请点赞关注再收藏
力扣习题
- 括号匹配问题。
- 用队列实现栈。
- 用栈实现队列。
- 设计循环队列。
- 有效的括号
//用栈来实现
//左括号进栈 右括号出栈并销毁如果不匹配则return
#include 225. 用队列实现栈（力扣）
//设置两个队列，入栈向有元素的队列加入， 出栈（因为栈上后进先出）所以需要把有元素的队列依次移入另一个队列 再删除
typedef int QDatetype;
typedef struct Qnode
{
int* next;
QDatetype x;
}Qnode;
typedef struct Queue
{
Qnode* head;
Qnode* tail;
}Queue;
typedef struct {
Queue Qtwo;
Queue Qone;
} MyStack;
void QueueInit(Queue* pq)
{
assert(pq);
pq->tail = pq->head = NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
while (pq->head)
{
Qnode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
void QueuePush(Queue* pq, QDatetype q)
{
assert(pq);
Qnode* newnode = (Qnode*)malloc(sizeof(Qnode));
newnode->next = NULL;
newnode->x = q;
if (pq->head == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
if(pq->head == pq->tail)
{
free(pq->head);
pq->head = pq->tail= NULL;
}
else
{
Qnode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
QDatetype QueueTop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->x;
}
int QueueSize(Queue* pq)
{
assert(pq);
Qnode* head = pq->head;
int size = 0;
while (head)
{
size++;
head = head->next;
}
return size;
}
QDatetype QueueTail(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->x;
}
//创造一个由队列创建的栈
MyStack* myStackCreate() {
MyStack* pq = (MyStack*)malloc(sizeof(MyStack));
//向堆申请空间不会随栈的销毁而销毁
QueueInit(&pq->Qtwo);
QueueInit(&pq->Qone);
return pq;
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->Qone) && QueueEmpty(&obj->Qtwo);
}
void myStackPush(MyStack* obj, int x) {
Queue* one = &obj-> Qone;
Queue* two = &obj-> Qtwo;
if(!QueueEmpty(one))
{
QueuePush(one, x);
}
else
{
QueuePush(two,x);
}
}
int myStackPop(MyStack* obj) {
Queue* noempty = &obj-> Qone;
Queue* empty = &obj-> Qtwo;
if(!QueueEmpty(empty) )
{
empty = &obj->Qone;
noempty = &obj->Qtwo;
}
while(QueueSize(noempty) >1)
{
QueuePush(empty, QueueTop(noempty));
QueuePop(noempty);
}
int x = QueueTop(noempty);
QueuePop(noempty);
return x;
}
int myStackTop(MyStack* obj) {
Queue* one = &obj-> Qone;
Queue* two = &obj-> Qtwo;
if(!QueueEmpty(one))
{
return QueueTail(one);
}
else
{
return QueueTail(two);
}
}
void myStackFree(MyStack* obj) {
QueueDestory(&obj->Qone);
QueueDestory(&obj->Qtwo);
free(obj);
}
myStackPop函数的功能实现图
232. 用栈实现队列（力扣）
//与用队列实现栈的思想不同， 这里的栈分别是push栈 和pop栈 （专门用来插入数据和删除数据）
#include myQueuePop主要功能图
622. 设计循环队列
//主要是用顺序表存储数据
//不用链表实现是因为1.找尾不容易找到，2，链表是否存满不好判断
typedef struct {
int front;
int rear ;
int k;
int* a;
} MyCircularQueue;
//公开辟（k+1）个空间 判断是否判空
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* pq = ( MyCircularQueue*)malloc(sizeof( MyCircularQueue));
pq->front = pq->rear= 0;
pq->k = k;
pq->a = (int*)malloc(sizeof(int)*(k+1));
return pq;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->rear == obj->front ;
}
//rear+1 = front则链表满了
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->rear +1) % (obj->k+1) == (obj->front);
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if (!myCircularQueueIsFull(obj))
{
obj->a[obj->rear] = value;
obj->rear = (++obj->rear % (obj->k+1));//rear++之后下标不能大于k+1，所以%（k+1）
return true;
}
return false;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return false;
}
else
{
++obj->front;
obj->front = obj->front%(obj->k+1);
return true;
}
}
int myCircularQueueFront(MyCircularQueue* obj) {
if(!myCircularQueueIsEmpty(obj))
{
return obj->a[obj->front];
}
else
{
return -1;
}
}
int myCircularQueueRear(MyCircularQueue* obj) {
if(!myCircularQueueIsEmpty(obj))
{
return obj->a[(obj->rear-1 + obj->k+1)%(obj->k+1)] ;
//rear--之后下标不能小于0
}
else
{
return -1;
}
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
obj->a = NULL;
free(obj);
obj = NULL;
}
