检测入栈出栈顺序是否正确的算法解析

检测入栈出栈顺序是否正确的算法解析

在计算机科学中，栈（Stack）是一种常见的数据结构，遵循后进先出（LIFO）的原则。在某些应用场景中，我们需要验证给定的入栈和出栈顺序是否合法。本文将详细解析一个用于判断入栈出栈顺序是否正确的算法。

问题描述

给定两个数组 a 和 b，分别表示入栈顺序和出栈顺序。我们需要判断是否可以通过一系列的入栈和出栈操作，使得最终的出栈顺序与数组 b 一致。

算法实现

以下是一个用C语言实现的算法，用于判断入栈出栈顺序是否正确：

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

typedef int TYPE;

typedef struct {
    TYPE* data;
    int top;
    int capacity;
} ArrayStack;

ArrayStack* create_Array_Stack(int capacity) {
    ArrayStack* stack = (ArrayStack*)malloc(sizeof(ArrayStack));
    stack->data = (TYPE*)malloc(capacity * sizeof(TYPE));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void push_array_stack(ArrayStack* stack, TYPE value) {
    if (stack->top < stack->capacity - 1) {
        stack->data[++stack->top] = value;
    }
}

bool pop_array_stack(ArrayStack* stack) {
    if (stack->top >= 0) {
        stack->top--;
        return true;
    }
    return false;
}

bool top_array_stack(ArrayStack* stack, TYPE* value) {
    if (stack->top >= 0) {
        *value = stack->data[stack->top];
        return true;
    }
    return false;
}

void destory_array_stack(ArrayStack* stack) {
    free(stack->data);
    free(stack);
}

bool is_pop_stack(int a[], int b[], int len) {
    ArrayStack* stack = create_Array_Stack(len);
    if (stack == NULL) {
        printf("创建栈失败\n");
        return false;
    }

    int a_index = 0;
    int b_index = 0;

    while (b_index < len) {
        TYPE val;
        if (top_array_stack(stack, &val) && val == b[b_index]) {
            pop_array_stack(stack);
            b_index++;
        } else {
            if (a_index >= len) {
                destory_array_stack(stack);
                printf("无法匹配出栈序列\n");
                return false; // 无法匹配出栈序列
            }
            push_array_stack(stack, a[a_index]);
            a_index++;
        }
    }
    destory_array_stack(stack);
    printf("匹配成功\n");
    return true;
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int b[] = {4, 5, 3, 2, 1};
    int len = sizeof(a) / sizeof(a[0]);

    if (is_pop_stack(a, b, len)) {
        printf("入栈出栈顺序正确\n");
    } else {
        printf("入栈出栈顺序不正确\n");
    }

    return 0;
}

算法解析

1. 创建栈

首先，我们定义了一个 ArrayStack 结构体来表示栈，并实现了创建栈的函数 create_Array_Stack。

ArrayStack* create_Array_Stack(int capacity) {
    ArrayStack* stack = (ArrayStack*)malloc(sizeof(ArrayStack));
    stack->data = (TYPE*)malloc(capacity * sizeof(TYPE));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

2. 入栈和出栈操作

我们实现了入栈 push_array_stack 和出栈 pop_array_stack 函数，以及获取栈顶元素 top_array_stack 的函数。

void push_array_stack(ArrayStack* stack, TYPE value) {
    if (stack->top < stack->capacity - 1) {
        stack->data[++stack->top] = value;
    }
}

bool pop_array_stack(ArrayStack* stack) {
    if (stack->top >= 0) {
        stack->top--;
        return true;
    }
    return false;
}

bool top_array_stack(ArrayStack* stack, TYPE* value) {
    if (stack->top >= 0) {
        *value = stack->data[stack->top];
        return true;
    }
    return false;
}

3. 判断入栈出栈顺序

核心函数 is_pop_stack 用于判断给定的入栈和出栈顺序是否合法。

bool is_pop_stack(int a[], int b[], int len) {
    ArrayStack* stack = create_Array_Stack(len);
    if (stack == NULL) {
        printf("创建栈失败\n");
        return false;
    }

    int a_index = 0;
    int b_index = 0;

    while (b_index < len) {
        TYPE val;
        if (top_array_stack(stack, &val) && val == b[b_index]) {
            pop_array_stack(stack);
            b_index++;
        } else {
            if (a_index >= len) {
                destory_array_stack(stack);
                printf("无法匹配出栈序列\n");
                return false; // 无法匹配出栈序列
            }
            push_array_stack(stack, a[a_index]);
            a_index++;
        }
    }
    destory_array_stack(stack);
    printf("匹配成功\n");
    return true;
}

4. 主函数

在主函数中，我们定义了入栈顺序 a 和出栈顺序 b，并调用 is_pop_stack 函数进行判断。

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int b[] = {4, 5, 3, 2, 1};
    int len = sizeof(a) / sizeof(a[0]);

    if (is_pop_stack(a, b, len)) {
        printf("入栈出栈顺序正确\n");
    } else {
        printf("入栈出栈顺序不正确\n");
    }
    
    return 0;

}

总结

通过上述算法，我们可以有效地判断给定的入栈和出栈顺序是否合法。该算法通过模拟栈的操作，验证了给定的入栈和出栈顺序是否能够匹配。