代码随想录刷题——栈与队列

栈与队列

用栈实现队列

题目链接

#define Max 100
typedef struct{
    int *s;//存放栈内元素;
    int size;//栈内元素数量
}Stack;
Stack* CreateStack(int x){//创建栈
    Stack* st=malloc(sizeof(Stack));
    st->s=malloc(sizeof(int)*x);
    st->size=0;
    return st;
}
//入栈
void PushStack(Stack* st,int x){
    st->s[st->size]=x;
    st->size=st->size+1;
}
//出栈,假设一定有元素
void PopStack(Stack* st){
   
    st->size=st->size-1;
}
//获取栈顶元素
int PeekStack(Stack* st){
    return st->s[st->size-1];
}
//判断栈是否空
bool EmptyStack(Stack* st){
    return st->size==0;
}
//用栈完成队列操作：入队时放入入队栈，
//出队时取出出队栈的栈顶元素，若为空，则将入队栈中的元素放入出队栈中
typedef struct {
    Stack *out;
    Stack *in;    
} MyQueue;
void FreeStack(Stack *st){
    free(st->s);
}

MyQueue* myQueueCreate() {
    MyQueue *q=malloc(sizeof(MyQueue));
    q->out=CreateStack(100);
    q->in =CreateStack(100);
    return q;
}
//入队，将元素放入入队栈
void myQueuePush(MyQueue* obj, int x) {
    PushStack(obj->in,x);
}
//出队，取出出队栈的栈顶元素，若为空，则将入队栈中的元素放入出队栈中
int myQueuePop(MyQueue* obj) {
    int x;
    if(EmptyStack(obj->out)){
        while(!EmptyStack(obj->in)){
            PushStack(obj->out,PeekStack(obj->in));
            PopStack(obj->in);
        }
    }
    x=PeekStack(obj->out);
    PopStack(obj->out);
    return x;
}

int myQueuePeek(MyQueue* obj) {
    int x;
    if(EmptyStack(obj->out)){
        while(!EmptyStack(obj->in)){
            PushStack(obj->out,PeekStack(obj->in));
            PopStack(obj->in);
        }
    }
    x=PeekStack(obj->out);
    return x;
}

bool myQueueEmpty(MyQueue* obj) {
    return EmptyStack(obj->in)&&EmptyStack(obj->out);
}

void myQueueFree(MyQueue* obj) {
    FreeStack(obj->in);
    FreeStack(obj->out);
}

/**
 * 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);
*/

用队列实现栈

题目链接

思路见代码

//用两个队列，一个为空，一个放元素
//当模拟出栈操作时，将有元素的队列除了最后一个元素，全部放入另一个队列，剩余的一个元素当作出栈元素
//若仅用一个队列模拟，那么模拟出栈操作时将出队的元素放入队尾，直到原来的队尾元素到队首
#define Max 100
typedef struct {
    int *queue;
    int front;//队首
    int rear;//队尾
} MyStack;

//这里用一个队列模拟栈
MyStack* myStackCreate() {
    MyStack *st=malloc(sizeof(MyStack));
    st->queue=malloc(sizeof(int)*Max);
    st->front=0;
    st->rear=0;
    return st;
}
//入栈
void myStackPush(MyStack* obj, int x) {
    obj->queue[obj->front]=x;
    obj->front=obj->front+1;
}
//出栈
int myStackPop(MyStack* obj) {
    int front=obj->front;
    int rear=obj->rear;
    int size=front-rear;
    for(int i=0;i<size-1;i++){
        obj->queue[front++]=obj->queue[rear++];
    }
    int top=obj->queue[rear++];
    obj->front=front;
    obj->rear=rear;
    return top;
}

int myStackTop(MyStack* obj) {
    return obj->queue[obj->front-1];
}

bool myStackEmpty(MyStack* obj) {
    return obj->front==obj->rear;
}

void myStackFree(MyStack* obj) {
    
    free(obj->queue);
}

/**
 * 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);
*/

有效的括号

题目链接

//括号匹配
//遇到左括号入栈，遇到右括号，则与栈顶左括号匹配，匹配成功则出栈，匹配失败返回false
//最后还要检查栈是否为空
bool match(char a,char b){
    if(a=='(')return b==')';
    else if(a=='{')return b=='}';
    else return b==']';
}
bool isValid(char* s) {
    char st[10000+5];
    int size=0;
    int len=strlen(s);
    for(int i=0;i<len;i++){
        if(s[i]=='('||s[i]=='['||s[i]=='{'){
            st[size++]=s[i];
        }
        else {
            if(size==0)return false;
            else if(!match(st[size-1],s[i]))return false;
            else{
                size--;
            }
        }
    }
    if(size!=0)return false;
    return true;
}

删除字符串中的所有相邻重复项

题目链接

思路：栈+模拟

char* removeDuplicates(char* s) {
    int len=strlen(s);
    char *st=malloc(sizeof(char)*(len+1));
    
    int size=0;
    for(int i=0;i<len;i++){
        if(size>0){
            if(s[i]==st[size-1]){
                size--;
            }
            else st[size++]=s[i];
        }
        else st[size++]=s[i];
    }
    st[size]='\0';//注意字符串数组最后要加'\0'
    return st;
}

逆波兰表达式求值

题目链接

思路：模拟

// 遇到操作数入栈，遇到操作符出栈运算
int cal(int a, int b, char op) {
    if (op == '+')
        return a + b;
    else if (op == '-')
        return a - b;
    else if (op == '*')
        return a * b;
    else
        return a / b;
}
int StringToNum(char* s) {
    int ans = 0;
    if (s[0] == '-') {
        for (int i = 1; s[i] != '\0'; i++) {
            ans = ans * 10 + (s[i] - '0');
        }
        ans = 0 - ans;
    } else {
        for (int i = 0; s[i] != '\0'; i++) {
            ans = ans * 10 + (s[i] - '0');
        }
    }
    return ans;
}
int evalRPN(char** tokens, int tokensSize) {
    int st[10000 + 5];
    int size = 0;
    
    for (int i = 0; i < tokensSize; i++) {
        if (strlen(tokens[i])==1&&(tokens[i][0]=='+'||tokens[i][0]=='-'||tokens[i][0]=='*'||tokens[i][0]=='/')) {
            int a = st[size - 1];
            int b = st[size-2];
            size-=2;
            int res=cal(b,a,tokens[i][0]);
            st[size++]=res;
        }
        else{
            st[size++]=StringToNum(tokens[i]);

        }
    }
    return st[0];
}

滑动窗口最大值

题目链接

思路：维护单调队列，队首为最大值

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
    int queue[numsSize];
    int head=0,tail=-1;//队首与队尾
    int l=0,r=0;//滑动窗口的左界、右界
    while(r<numsSize){
        if(r-l<k){//相当于入队操作
            while(tail>=head&&nums[r]>queue[tail]){
                tail--;
            }
            queue[++tail]=nums[r++];
        }
        if(r-l>=k){
            if(nums[l]==queue[head])head++;
            else nums[l]=queue[head];
            l++;
        }
    }
    *returnSize=numsSize-k+1;
    return nums;
}

前K个高频元素

方法一：堆

题目链接
官方代码，我不会

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct hash_stable{
    int key;
    int val;
    UT_hash_handle hh;
};
typedef struct hash_stable* hash_ptr;
struct pair{
    int first;
    int second;
};
struct pair* heap;
int heapSize;
void swap(struct pair*a,struct pair *b){
    struct pair t=*a;
    *a=*b;
    *b=t;
}
bool cmp(struct pair* a,struct pair* b){
    return a->second<b->second;
}

struct pair top(){
    return heap[1];
}
void push(hash_ptr x){
    //先放入栈尾
    heap[++heapSize].first=x->key;
    heap[heapSize].second=x->val;
    int p=heapSize;
    while(p>1){
        int s=p>>1;//s为p的父节点
        if(cmp(&heap[s],&heap[p]))return;//父节点更小则不需要换
        swap(&heap[s],&heap[p]);
        p=s;
    }
}
//取出堆顶
void pop(){
    heap[1]=heap[heapSize--];//将堆尾放入堆顶，在调整
    int p=1;
    while((p<<1)<=heapSize){
        int s=p<<1;
        if(s<heapSize&&cmp(&heap[s+1],&heap[s]))s++;//右孩子小于左孩子更小
        if(cmp(&heap[p],&heap[s]))return;
        swap(&heap[p],&heap[s]);
        p=s;
    }
}
int* topKFrequent(int* nums, int numsSize, int k, int* returnSize) {
    hash_ptr head=NULL;
    hash_ptr p=NULL,tmp=NULL;
    for(int i=0;i<numsSize;i++){
        HASH_FIND_INT(head,&nums[i],p);
        if(p==NULL){
            p=malloc(sizeof(struct hash_stable));
            p->key=nums[i];
            p->val=1;
            HASH_ADD_INT(head,key,p);
        }
        else{
            p->val++;
        }
    }
    heap=malloc(sizeof(struct pair)*(k+1));
    heapSize=0;
    HASH_ITER(hh,head,p,tmp){
        if(heapSize==k){
            struct pair tmp=top();
            if(tmp.second<p->val){
                pop();
                push(p);
            }
           
        }
         else {
                push(p);
            }
    }
    *returnSize=k;
    int *res=malloc(sizeof(int)*k);
    for(int i=0;i<k;i++){
        struct pair tmp=top();
        pop();
        res[i]=tmp.first;
    }
    return res;
}

方法二：后续补充