1.栈的最小值:
链接: 题目链接
这道题既然是求最小值,其实就是在栈的插入操作上进行一个判断选择,具体我就不多说了,栈的基础操作我看谁不会(dog):
#define MAX_SIZE 10000
typedef struct {
int nums[MAX_SIZE];
int mins[MAX_SIZE];
int top;
} MinStack;
/** initialize your data structure here. */
MinStack* minStackCreate() {
MinStack *obj = malloc(sizeof(MinStack));//初始化栈
obj->top = -1;
return obj;
}
void minStackPush(MinStack* obj, int x) {
if(obj->top ==MAX_SIZE -1) return ;//首先进行判断,如果栈满,则退出
obj->top++;
obj->nums[obj->top] = x;//x数据入栈了
if(obj->top == 0)
{
obj->mins[obj->top] = x;//首先直接进栈
}
else
{
obj->mins[obj->top] = fmin(obj->mins[obj->top-1],x);//每进栈一个就进行判断选择
}
}
void minStackPop(MinStack* obj) {
if(obj->top == -1) return ;
obj->top--;//退栈
}
int minStackTop(MinStack* obj) {
return obj->nums[obj->top];//返回栈顶元素
}
int minStackGetMin(MinStack* obj) {
return obj->mins[obj->top];//返回目标栈顶元素,题目要求的,我们是将最小数据放进min栈的,所以直接返回就好了.
}
void minStackFree(MinStack* obj) {
free(obj);//释放栈
}
2.设计一个支持增量操作的栈:
链接: 题目链接
这道题的思路也很清晰,就是在栈操作的基础上进行自增运算,if判断自增个数,控制i循环条件:
typedef struct {
int elem[1001];//设大一点多好
int top;
int maxSize;
} CustomStack;
CustomStack* customStackCreate(int maxSize) {//栈的初始化
CustomStack * obj;
obj = (CustomStack *)malloc(sizeof(CustomStack));
obj->top = 0;
obj->maxSize = maxSize;
return obj;
}
void customStackPush(CustomStack* obj, int x) {
if(obj->top == obj->maxSize)//栈满则退出
return ;
else
{
obj->top++;
obj->elem[obj->top] = x;//入栈
}
}
int customStackPop(CustomStack* obj) {
if(obj->top == 0) return -1;//栈空返回-1
else
{
return obj->elem[obj->top--];//返回栈顶元素
}
}
void customStackIncrement(CustomStack* obj, int k, int val) {
int i;
if(obj->top+1<=k)//+1是因为obj->top从0开始
{
for(i=0;i<obj->top+1;i++)
{
obj->elem[i] += val;
}
}
else
{
for(i=0;i<k+1;i++)
{
obj->elem[i] +=val;
}
}
}
void customStackFree(CustomStack* obj) {
free(obj);//释放栈
}
3.设计循环队列:
链接:链接: 题目链接
这道题核心思路为对队队满与队空为基准,队满(obj->rear+1)%obj->size == obj->front,队空obj->rear==obj->front为条件,再就是提取队首与队尾元素,代码如下:
typedef struct {
int front;//队首
int rear;//队尾
int size;//数据域数组大小
int data[];//数据域
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue *Q = (MyCircularQueue *)malloc(sizeof(MyCircularQueue) + sizeof(int)*(k + 1));//动态开辟内存空间,(k+1)是因为防止front与rear重合,最后提取元素容易越界提取
Q -> size = k + 1;//多一个内存区别队满与队空的情况
Q -> front = 0;
Q -> rear = 0;
return Q;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if ((obj -> rear + 1) % obj -> size == obj -> front) {
return false;//队满
}
obj -> data[obj -> rear] = value;
obj -> rear = (obj -> rear + 1)%obj -> size;//进队
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if (obj -> front == obj -> rear) {
return false;//队空
}
obj -> front = (obj -> front + 1) % obj -> size;
return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
if (obj -> front == obj -> rear) {
return -1;
}
return obj -> data[obj -> front];
}
int myCircularQueueRear(MyCircularQueue* obj) {
if (obj -> front == obj -> rear) {
return -1;
}
return obj -> rear == 0 ? obj -> data[obj -> size - 1] : obj -> data[obj -> rear - 1];"? :"相当于if else语句,当obj -> rear == 0,执行obj -> data[obj -> size - 1],因为此时队列中只有唯一元素,而队尾指针指向的是元素的下个位置,所以需要[obj->size-1],反之就返回[obj->rear-1]
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
if (obj -> front == obj -> rear) {
return true;
}
return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
if ((obj -> rear + 1) % obj -> size == obj -> front) {
return true;
}
return false;
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj);//释放节点
}
4.队列的最大值:
链接: 题目链接
这道题的解题方法,首先使用循环队列,不用担心溢出问题,其次即为队满与队空的判断,上面一题用的第一种队首与队尾方法去判断,这一题用第二种,再定义一个计数器,当其为0时队空,为maxsize队满,代码如下:
typedef struct {
int elem[10000];
int rear;
int front;
int count;//计数器
} MaxQueue;
MaxQueue* maxQueueCreate() {
MaxQueue*obj=(MaxQueue*)malloc(sizeof(MaxQueue));//初始化队列
obj->front=0;
obj->rear=0;
obj->count=0;
return obj;
}
int maxQueueMax_value(MaxQueue* obj) {
if(obj->count==0)
return -1;//队空
int max=obj->elem[obj->front];
for(int i=(obj->front)+1;i<=obj->rear;i++)
{
if(obj->elem[i]>max)
max=obj->elem[i];//选出最大值
}
return max;
}
void maxQueuePush_back(MaxQueue* obj, int value) {
if(obj->count==10000)
return ;//队满
else
obj->elem[obj->rear]=value;//入队
obj->rear++;
obj->count++;
}
int maxQueuePop_front(MaxQueue* obj) {
int ret=-1;
if(obj->count == 0)
return -1;
ret=obj->elem[obj->front];//出队
obj->front++;
obj->count--;
return ret;
}
void maxQueueFree(MaxQueue* obj) {
free(obj);//释放队
}