栈与队列

队列

• 性质：先进先出（队尾入队，队头出队）
• 分类：
  
  • 单向队列
  • 循环队列
  • 单调队列
  • 优先队列

栈

• 性质：先进后出（队尾入栈，队尾出栈）
• 分类：
  
  • 单项队列
  • 单调栈

栈适合解决所有完全包含关系的问题

单调队列 : 均摊时间复杂度O(1), 适用于解决查询区间最值问题（线段树也适用）

问题：在一个序列中需要一个五位的字串，排序后保证每一个数字只出现一次

解决方法：滑动窗口法，利用两个单调队列，一个维护区间最大值，一个维护区间最小值，然后利用最大值减去最小值即可解决。

---

数据结构 = 结构定义 + 结构操作

---

演示代码：

栈

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define data_type int
#define NULL_VALUE 0
//栈适合解决所有完全包含关系的问题
typedef struct Stack {
    data_type *data;
    int top, size;
} Stack;

Stack* init(int);
void clear(Stack*);
data_type top(Stack*);
int push(Stack*, data_type);
int pop(Stack*);
int empty(Stack*);
void output(Stack*);
int main() {
    srand(time(0));
    Stack *s = init(20);
    for (int i = 0; i < 20; i++) {
        int op = rand() % 2, value = rand() % 100;
        switch (op) {
            case 0: {
                printf("push element = %d to stack\n", value);
                push(s, value);
                output(s);        
            } break;
            case 1: {
                printf("pop element from stack\n");
                pop(s);
                output(s);
            } break;
            default:
                fprintf(stderr, "error operator = %d\n", op);
                break;
        }
    }
    clear(s);
}
Stack* init(int n) {
    Stack *s = (Stack*)malloc(sizeof(Stack));
    s->data = (data_type*)malloc(sizeof(data_type) * n);
    s->size = n;
    s->top = -1;
    return s;
}
void clear(Stack* s) {
    if (s == NULL) return;
    free(s->data);
    free(s);
    return;
}
data_type top(Stack* s) {
    if (empty(s)) return NULL_VALUE;
    return s->data[s->top];
}
int push(Stack* s,data_type value) {
    if (s->top + 1 == s->size) {
        return 0;
    }
    s->top += 1;
    s->data[s->top] = value;
    return 1;
}
int pop(Stack* s) {
    if (empty(s)) return 0;
    s->top -= 1;
    return 1;
}
int empty(Stack* s) {
    return s->top == -1;    
}
void output(Stack* s) {
    printf("[");
    int index = 0;
    for (int i = 0; i < s->size; ++i) {
        if (i <= s->top) {
            index += printf("%d",s->data[i]);
            index += printf(",");
        }else {
            printf(",");
        }
    }
    printf("]\n");
    for (int i = 0; i < index-1; ++i) printf(" ");
    printf("^\n");
    for (int i = 0; i < index-1; ++i) printf(" ");
    printf("|\n");
    for (int i = 0; i < index-2; ++i) printf(" ");
    printf("top\n");
}

队列

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define data_type int
#define NULL_VALUE -16384

typedef struct Queue {
        data_type *data;
        int head, tail;
        int length;
        int count;
} Queue;

Queue *init(int n);
void clear(Queue *);
data_type front(Queue *);
int push(Queue *, data_type);
int pop(Queue *);
int empty(Queue *);

void output(Queue *q) {
    printf("[");
    for (int i = 0, head = q->head;i < q->count; i++, head = (head + 1) % q->length) {
        printf("%d, ", q->data[head]);               
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    Queue *q = init(10);
    for (int i = 0; i < 20; i++) {
        int op = rand() % 2, value = rand() % 100;
        if (op == 1) {
            printf("insert %d to queue\n", value);
            push(q, value);
            output(q);
        } else {
            printf("pop element from queue = %d\n", pop(q));
            output(q);
        }
    }
    return 0;

}

Queue *init(int n) {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->data = (data_type *)malloc(sizeof(data_type) * n);
    q->head = 0;
    q->tail = -1;
    q->count = 0;
    q->length = n;
    return q;
}

void clear(Queue *q) {
    if (q == NULL) return ;
    free(q->data);
    free(q);
    return;
}

data_type front(Queue *q) {
    if (empty(q)) return NULL_VALUE;
    return q->data[q->head];
}

int push(Queue *q, data_type value) {
    if (q->length == q->count) return 0;
    q->tail = (q->tail + 1) % q->length;
    q->count += 1;  
    q->data[q->tail] = value;
    return 1;
}

int pop(Queue *q) {
    if (empty(q)) return 0;
    q->count -= 1;
    q->head = (q->head + 1) % q->length;
    return 1;
}

int empty(Queue *q) {
    return q->count == 0;
}