ML-czy的小组任务2

最新推荐文章于 2024-08-15 05:02:54 发布

ML-czy

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量144

点赞数

分类专栏：算法题整理文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/qq_61712022/article/details/125983343

版权

算法题整理专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了如何设计高效的数据结构，包括求栈中最小值的栈、支持自增操作的栈以及循环队列。详细阐述了每个数据结构的实现原理和关键操作，如最小值栈的最小值获取、自增栈的增量操作以及循环队列的入队、出队和判断队满队空的方法。这些设计展示了在有限空间内实现高效数据操作的策略。

摘要由CSDN通过智能技术生成

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);//释放队
}