day28_LC学习计划：数据结构基础

155.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。
 

示例 1:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.
 

提示：

-231 <= val <= 231 - 1
pop、top 和 getMin 操作总是在 非空栈 上调用
push, pop, top, and getMin最多被调用 3 * 104 次

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-stack
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

设计辅助栈。

#define MAXSIZE 10000

typedef struct MinStack{
    int* stk,* minStk;
    int top,minTop;
} MinStack;


MinStack* minStackCreate() {
    MinStack* stack=malloc(sizeof(MinStack));
    stack->stk=malloc(sizeof(int)*MAXSIZE);
    stack->minStk=malloc(sizeof(int)*(MAXSIZE+1));
    stack->top=-1;
    stack->minTop=-1;
    stack->minStk[++stack->minTop]=INT_MAX;
    return stack;
}

void minStackPush(MinStack* obj, int val) {
    if(obj->top<MAXSIZE){
        (obj->stk)[++(obj->top)]=val;
        if(val<obj->minStk[obj->minTop]){
            obj->minStk[++obj->minTop]=val;
        }else{
            obj->minStk[++obj->minTop]=obj->minStk[obj->minTop];
        }
    }
}

void minStackPop(MinStack* obj) {
    if(obj->top>-1){
        obj->stk[obj->top--];
        obj->minStk[obj->minTop--];
    }
}

int minStackTop(MinStack* obj) {
    if(obj->top>-1){
        return (obj->stk)[obj->top];
    }
    return;
}

int minStackGetMin(MinStack* obj) {
    if(obj->top>-1){
        return obj->minStk[obj->minTop];
    }
    return;
}

void minStackFree(MinStack* obj) {
    free(obj->stk);
    obj->stk=NULL;
    free(obj->minStk);
    obj->minStk=NULL;
    free(obj);
    obj=NULL;
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, val);
 
 * minStackPop(obj);
 
 * int param_3 = minStackTop(obj);
 
 * int param_4 = minStackGetMin(obj);
 
 * minStackFree(obj);
*/

1249.移除无效的括号

给你一个由 '('、')' 和小写字母组成的字符串 s。

你需要从字符串中删除最少数目的 '(' 或者 ')' （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。

请返回任意一个合法字符串。

有效「括号字符串」应当符合以下 任意一条 要求：

• 空字符串或只包含小写字母的字符串
• 可以被写作 AB（A 连接 B）的字符串，其中 A 和 B 都是有效「括号字符串」
• 可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」

示例 1：

输入：s = "lee(t(c)o)de)"
输出："lee(t(c)o)de"
解释："lee(t(co)de)" , "lee(t(c)ode)" 也是一个可行答案。

示例 2：

输入：s = "a)b(c)d"
输出："ab(c)d"

示例 3：

输入：s = "))(("
输出：""
解释：空字符串也是有效的

提示：

• 1 <= s.length <= 105
• s[i] 可能是 '('、')' 或英文小写字母

 利用栈存储左括号的坐标，找到左括号时入栈，找到右括号时如果栈空，说明右括号需要移除，标记移除，如果不为空则弹栈。循环字符串结束栈还没有空说明也都是需要移除的左括号，移除即可。

char * minRemoveToMakeValid(char * s){
    int stack[strlen(s)],top=-1,len=0;
    char* ret=malloc(sizeof(char)*(strlen(s)+3));
    for(int i=0;i<strlen(s);i++){
        if(s[i]=='('||s[i]==')'){
            if(s[i]=='('){
                stack[++top]=i;
            }else if(top==-1){
                s[i]='*';
            }else{
                stack[top--];
            }
        }
    }
    while(top>-1){
        s[stack[top--]]='*';
    }
    for(int i=0;i<strlen(s);i++){
        if(s[i]!='*'){
            ret[len++]=s[i];
        }
    }
    ret[len++]='\0';
    return ret;
}

 

共有 n 名小伙伴一起做游戏。小伙伴们围成一圈，按 顺时针顺序 从 1 到 n 编号。确切地说，从第 i 名小伙伴顺时针移动一位会到达第 (i+1) 名小伙伴的位置，其中 1 <= i < n ，从第 n 名小伙伴顺时针移动一位会回到第 1 名小伙伴的位置。

游戏遵循如下规则：

从第 1 名小伙伴所在位置 开始 。
沿着顺时针方向数 k 名小伙伴，计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数，一些小伙伴可能会被数过不止一次。
你数到的最后一名小伙伴需要离开圈子，并视作输掉游戏。
如果圈子中仍然有不止一名小伙伴，从刚刚输掉的小伙伴的 顺时针下一位 小伙伴 开始，回到步骤 2 继续执行。
否则，圈子中最后一名小伙伴赢得游戏。
给你参与游戏的小伙伴总数 n ，和一个整数 k ，返回游戏的获胜者。

示例 1：

输入：n = 5, k = 2
输出：3
解释：游戏运行步骤如下：
1) 从小伙伴 1 开始。
2) 顺时针数 2 名小伙伴，也就是小伙伴 1 和 2 。
3) 小伙伴 2 离开圈子。下一次从小伙伴 3 开始。
4) 顺时针数 2 名小伙伴，也就是小伙伴 3 和 4 。
5) 小伙伴 4 离开圈子。下一次从小伙伴 5 开始。
6) 顺时针数 2 名小伙伴，也就是小伙伴 5 和 1 。
7) 小伙伴 1 离开圈子。下一次从小伙伴 3 开始。
8) 顺时针数 2 名小伙伴，也就是小伙伴 3 和 5 。
9) 小伙伴 5 离开圈子。只剩下小伙伴 3 。所以小伙伴 3 是游戏的获胜者。
示例 2：

 

输入：n = 6, k = 5
输出：1
解释：小伙伴离开圈子的顺序：5、4、6、2、3 。小伙伴 1 是游戏的获胜者。
 

提示：

1 <= k <= n <= 500

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-the-winner-of-the-circular-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

约瑟夫环，用链表解决。之后的环形队列可以考虑都用链表替换。

typedef struct List{
    int val;
    struct List* next;
}ListNode;

int findTheWinner(int n, int k){
    //把n加入队列
    ListNode* head=malloc(sizeof(ListNode));
    head->val=1;
    head->next=NULL;
    ListNode* cur=head;
    for(int i=2;i<=n;i++){
        ListNode* tmp=malloc(sizeof(ListNode));
        tmp->val=i;
        tmp->next=NULL;
        cur->next=tmp;
        cur=tmp;
    }
    cur->next=head;

    //开始模拟
    ListNode* pre=head;
    while(pre->next!=head){
        pre=pre->next;
    }
    int tmp=k;
    while(head->next!=head){
        if(tmp-1==0){
            pre->next=pre->next->next;
            head=pre->next;
            tmp=k;
        }else{
            pre=head;
            head=head->next;
            tmp--;
        }
    }
    return head->val;
}