Cấu trúc dữ liệu ngăn xếp trong lập trình C/C++

#define MAX 100 // định nghĩa kích thước tối đa của ngăn xếp

struct Stack {
    int top; // vị trí của đỉnh trong mảng
    int arr[MAX]; // mảng để lưu trữ các phần tử
};

void initStack(Stack* s) {
    s->top = -1; // đặt top bằng -1 để biểu thị ngăn xếp rỗng
}

bool isEmpty(Stack* s) {
    return s->top == -1;
}

bool isFull(Stack* s) {
    return s->top == MAX - 1;
}


void push(Stack* s, int value) {
    if (isFull(s)) {
        cout << "Stack is full" << endl;
    } else {
        s->top++;
        s->arr[s->top] = value;
    }
}

int pop(Stack* s) {
    if (isEmpty(s)) {
        cout << "Stack is empty" << endl;
        return -1;
    } else {
        int value = s->arr[s->top];
        s->top--;
        return value;
    }
}

int peek(Stack* s) {
    if (isEmpty(s)) {
        cout << "Stack is empty" << endl;
        return -1;
    } else {
        return s->arr[s->top];
    }
}

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

#define MAX_SIZE 100 // định nghĩa kích thước tối đa của ngăn xếp

struct Stack {
    int items[MAX_SIZE]; // mảng để lưu trữ phần tử trong ngăn xếp
    int top; // biến đếm số phần tử hiện có trong ngăn xếp
};

void createStack(struct Stack *s) { // hàm khởi tạo ngăn xếp
    s->top = -1; // thiết lập top ban đầu là -1 để đánh dấu ngăn xếp rỗng
}

int isEmpty(struct Stack *s) { // hàm kiểm tra ngăn xếp rỗng
    return s->top == -1;
}

int isFull(struct Stack *s) { // hàm kiểm tra ngăn xếp đầy
    return s->top == MAX_SIZE - 1;
}

void push(struct Stack *s, int value) { // hàm đưa phần tử vào ngăn xếp
    if (isFull(s)) { // nếu ngăn xếp đã đầy thì hiển thị thông báo lỗi
        printf("Stack overflow\n");
    } else {
        s->top++; // tăng biến top để đánh dấu thêm một phần tử mới
        s->items[s->top] = value; // gán giá trị của phần tử mới vào mảng
    }
}

int pop(struct Stack *s) { // hàm lấy phần tử khỏi ngăn xếp
    if (isEmpty(s)) { // nếu ngăn xếp rỗng thì hiển thị thông báo lỗi và trả về giá trị -1
        printf("Stack underflow\n");
        return -1;
    } else {
        int value = s->items[s->top]; // lưu giá trị của phần tử cuối cùng vào biến value
        s->top--; // giảm biến top để đánh dấu bỏ đi một phần tử
        return value; // trả về giá trị của phần tử cuối cùng
    }
}

int peek(struct Stack *s) { // hàm lấy giá trị của phần tử ở đỉnh ngăn xếp
    if (isEmpty(s)) { // nếu ngăn xếp rỗng thì hiển thị thông báo lỗi và trả về giá trị -1
        printf("Stack is empty\n");
        return -1;
    } else {
        return s->items[s->top]; // trả về giá trị của phần tử ở đỉnh ngăn xếp
    }
}

int main() {
    struct Stack s;

// Tạo mới stack
createStack(&s);

// Thêm các phần tử vào stack
push(&s, 5);
push(&s, 10);
push(&s, 15);

// Hiển thị phần tử trên cùng của stack
printf("Top element: %d\n", peek(&s));

// Xóa phần tử trên cùng của stack
pop(&s);

// Hiển thị phần tử trên cùng của stack sau khi xóa phần tử trên cùng
printf("Top element: %d\n", peek(&s));

// Thêm các phần tử khác vào stack
push(&s, 20);
push(&s, 25);

// Kiểm tra xem stack có đầy không
if (isFull(&s)) {
    printf("Stack is full\n");
} else {
    printf("Stack is not full\n");
}

// Lấy các phần tử từ stack cho đến khi stack trống
while (!isEmpty(&s)) {
    int value = pop(&s);
    printf("%d ", value);
}

printf("\n");

return 0;
}

struct Node {
    int data;
    struct Node* next;
};

Hàm tạo 1 nút mới
struct Node* newNode(int data) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node)); //Khai báo và cấp phát bộ nhớ cho nút mới
    node->data = data; //Gắn data cho nút
    node->next = NULL; //Cho nút này trỏ tới 1 node tiếp theo là NULL
    return node;
}

int isEmpty(struct Node* root) {
    return !root;
}

void push(struct Node** root, int data) {
    struct Node* node = newNode(data);
    node->next = *root;
    *root = node;
}

int pop(struct Node** root) {
    if (isEmpty(*root)) {
        printf("Stack Underflow\n");
        return INT_MIN;
    }
    struct Node* temp = *root;
    *root = (*root)->next;
    int popped = temp->data;
    free(temp);
    return popped;
}

int peek(struct Node* root) {
    if (isEmpty(root)) {
        printf("Stack is empty\n");
        return INT_MIN;
    }
    return root->data;
}

int outputStack(struct Node* root) {
    if (isEmpty(root)) {
        printf("Stack is empty\n");
        return INT_MIN;
    }
    return root->data;
}

void destroyStack(struct Node** root) {
    struct Node* current = *root;
    struct Node* next;

    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }

    *root = NULL;
}

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

// Định nghĩa cấu trúc cho một nút trong linked list
struct Node {
    int data;         // Dữ liệu của nút
    struct Node* next; // Con trỏ đến nút tiếp theo trong danh sách
};

// Hàm để tạo một nút mới
struct Node* newNode(int data) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->next = NULL;
    return node;
}

// Hàm để thêm một phần tử vào đầu ngăn xếp
void push(struct Node** top, int data) {
    struct Node* node = newNode(data);
    node->next = *top;
    *top = node;
    printf("%d pushed to stack\n", data);
}

// Hàm để lấy phần tử trên đầu ngăn xếp
int pop(struct Node** top) {
    if (*top == NULL) {
        printf("Stack is empty\n");
        return -1;
    }
    struct Node* node = *top;
    *top = node->next;
    int data = node->data;
    free(node);
    return data;
}

// Hàm để hiển thị tất cả các phần tử trong ngăn xếp
void display(struct Node* node) {
    if (node == NULL) {
        printf("Stack is empty\n");
        return;
    }
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    struct Node* top = NULL;

    // Thêm các phần tử vào ngăn xếp
    push(&top, 1);
    push(&top, 2);
    push(&top, 3);

    // Hiển thị tất cả các phần tử trong ngăn xếp
    printf("Stack: ");
    display(top);

    // Lấy phần tử trên đầu ngăn xếp và hiển thị
    int data = pop(&top);
    printf("%d popped from stack\n", data);

    // Hiển thị tất cả các phần tử trong ngăn xếp
    printf("Stack: ");
    display(top);

    return 0;
}