数据结构 - 栈和队列

---

使用场景

栈用来回溯和匹配一些进出情况，队列用来先进先出，实际应用中可用来缓冲一些请求

栈

C 语言实现

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define COLOR(a, b) "\033[" #b "m" a "\033[0m"
#define GREEN(a) COLOR(a, 32)

typedef struct Stack {
    int *data;
    int size, top;
} Stack;

Stack *init(int n) {
    Stack *s = (Stack *) malloc(sizeof(Stack));
    s->data = (int *) malloc(sizeof(int) * n);
    s->size = n;
    s->top = -1;
    return s;
}

int empty(Stack *s) {
    return s->top == -1;
}

int top(Stack *s) {
    return s->data[s->top];
}

int expand(Stack *s) {
    int extr_size = s->size;
    int *p;
    while (extr_size) {
        p = (int *)realloc(s->data, sizeof(int) * (s->size + extr_size));
        if (p) break;
        extr_size >>= 1;
    }
    if (p == NULL) return 0;
    s->data = p;
    s->size += extr_size;
    return 1;
}

int push(Stack *s, int val) {
    if (s == NULL) return 0;
    if (s->top == s->size - 1) {
        if (!expand(s)) return 0;
        printf(GREEN("expand successfully! Stack->size = (%d)\n"), s->size);
    }
    s->data[++(s->top)] = val;
    return 1;
}

int pop(Stack *s) {
    if (s == NULL) return 0;
    if (empty(s)) return 0;
    s->top -= 1;
    return 1;
}

void output(Stack *s) {
    if (s == NULL) return;
    printf("[");
    for (int i = 0; i <= s->top; ++i) {
        i && printf(", ");
        printf("%d", s->data[i]);
    }
    printf("]\n");
    return ;
}

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

int main() {
    srand(time(0));
    #define max_op 20
    Stack *s = init(2);
    int flag;
    for (int i = 0; i < max_op; ++i) {
        int val = rand() % 100;
        int op = rand() % 4;
        switch(op) {
            case 0:
            case 1:
            case 2:
                printf("push %d to the Stack = %d\n", val, push(s, val));
                break;
            case 3:
                flag = !empty(s);
                flag && printf("pop %d from the Stack, ", top(s));
                printf("result = %d\n", pop(s));
                break;
        }
        output(s), printf("\n");
    }
    #undef max_op
    clear(s);
    return 0;
}

C++ 实现

class Stack {
private:
    int*elements;
    int max_size, top_index;
public:
    Stack(int length_input) {
        elements = new int[length_input];
        max_size = length_input;
        top_index = -1;
    }
    ~Stack() {
        delete[] elements;
    }
    bool push(const int &element) {
        if (top_index >= max_size - 1) {
            return false;
        }
        top_index++;
        elements[top_index] = element;
        return true;
    }
    bool pop() {
        if (top_index < 0) {
            return false;
        }
        top_index--;
        return true;
    }
    int top() {
        assert(top_index >= 0);
        return elements[top_index];
    }
    bool empty() {
        return top_index < 0;
    }
};

队列

C 语言实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define COLOR(a, b) "\033[" #b "m" a "\033[0m"
#define GREEN(a) COLOR(a, 32)

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

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

int front(Queue *q) {
    return q->data[q->head];
}

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

int expand(Queue *q) {
    int extr_size = q->length;
    int *p;
    while (extr_size) {
        p = (int *) malloc(sizeof(int) * (q->length + extr_size));
        if (p) break;
        extr_size >>= 1;
    }
    if (p == NULL) return 0;
    for (int i = q->head, j = 0; j < q->cnt; ++j) {
        p[j] = q->data[(i + j) % q->length];
    }
    free(q->data);
    q->data = p;
    q->length += extr_size;
    q->head = 0;
    q->tail = q->cnt;
    return 1;
}

int push(Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->cnt == q->length) {
        if (!expand(q)) return 0;
        printf(GREEN("expand successfully! Queue->size(%d)\n"), q->length);
    }
    q->data[q->tail++] = val;
    if (q->tail == q->length) q->tail = 0;
    q->cnt += 1;
    return 1;
}

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

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

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

int main() {
    srand(time(0));
    #define max_op 20
    Queue *q = init(2);
    for (int i = 0; i < max_op; ++i) {
        int val = rand() % 100;
        int op = rand() % 4;
        switch(op) {
            case 0:
            case 1:
            case 2:
                printf("push %d to the Queue! ", val);
                printf("result = %d\n", push(q, val));
                break;
            case 3:
                printf("pop %d from the Queue! ", front(q));
                printf("result = %d\n", pop(q));
                break;
        }
        output(q), printf("\n");
    }
    #undef max_op
    clear(q);
    return 0;
}

C++ 实现

class Queue {
private:
    int *data;
    int head, tail, length, count;
public:
    Queue(int length_input) {
        data = new int[length_input];
        length = length_input;
        head = 0;
        tail = -1;
        count = 0;
    }
    ~Queue() {
        delete[] data;
    }
    bool push(int element) {
        if (count >= length) {
            return false;
        }
        tail = (tail + 1) % length;
        data[tail] = element;
        count++;
        return true;
    }
    void output() {
        int i = head;
        do {
            cout << data[i] << " ";
            i = (i + 1) % length;
        } while(i != (tail + 1) % length);
        cout << endl;
    }
    int front() {
        return data[head];
    }
    void pop() {
        head = (head + 1) % length;
        count--;
    }
    bool empty() {
        return count == 0;
    }
};