C语言用栈实现括号匹配

您好！要实现C语言中的指针匹配，需要使用“&”符号来获取变量的地址，然后使用“*”符号来访问该地址处存储的值。下面是一个简单的例子：

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr = &num;  // 定义指针变量ptr并将其指向num的地址
    printf("num 的值为：%d\n", num);
    printf("ptr 指向的值为：%d\n", *ptr);
    return 0;
}

在上述代码中，我们定义了一个整型变量`num`，然后定义了一个指向`num`地址的整型指针变量`ptr`。通过`*ptr`可以访问`num`的值。输出结果为：

num 的值为：10
ptr 指向的值为：10

希望这个例子能够帮助您理解C语言中指针的用法。如果您有任何问题，请随时与我联系。

相关问题

c语言中用栈实现括号匹配

好的，以下是使用 C 语言实现括号匹配的示例代码：

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

#define MAX_SIZE 100

typedef struct {
    char data[MAX_SIZE];
    int top;
} Stack;

void init(Stack *s) {
    s->top = -1;
}

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

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

void push(Stack *s, char c) {
    if (is_full(s)) {
        printf("Stack overflow!\n");
        exit(1);
    }
    s->top++;
    s->data[s->top] = c;
}

char pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow!\n");
        exit(1);
    }
    char c = s->data[s->top];
    s->top--;
    return c;
}

bool is_valid(char *s) {
    Stack stack;
    init(&stack);
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (c == '(' || c == '[' || c == '{') {
            push(&stack, c);
        } else {
            if (is_empty(&stack)) {
                return false;
            }
            char top = pop(&stack);
            if (c == ')' && top != '(') {
                return false;
            }
            if (c == ']' && top != '[') {
                return false;
            }
            if (c == '}' && top != '{') {
                return false;
            }
        }
    }
    return is_empty(&stack);
}

int main() {
    char s1[] = "()[]{}";
    char s2[] = "([)]";
    char s3[] = "{[]()}";
    printf("%d\n", is_valid(s1));
    printf("%d\n", is_valid(s2));
    printf("%d\n", is_valid(s3));
    return 0;
}

这里我们使用了结构体实现栈，其中 `init` 用于初始化栈，`is_empty` 用于判断栈是否为空，`is_full` 用于判断栈是否已满，`push` 用于将元素入栈，`pop` 用于将元素出栈。在 `is_valid` 函数中，我们遍历字符串中的每一个字符，如果遇到左括号，则将其入栈；如果遇到右括号，则判断栈顶元素是否为对应的左括号，如果是则弹出栈顶元素，继续遍历字符串；如果不是，则括号不匹配，返回 false。最后，如果栈为空，则说明所有括号都匹配，返回 true；否则说明还有未匹配的括号，返回 false。

C语言 顺序栈实现括号匹配

好的，以下是 C 语言顺序栈实现括号匹配的代码示例：

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

#define MAXSIZE 100 // 栈的最大长度

typedef struct {
    char data[MAXSIZE];
    int top; // 栈顶指针
} Stack;

// 初始化栈
void InitStack(Stack *S) {
    S->top = -1;
}

// 判断栈是否为空
bool IsEmpty(Stack *S) {
    return S->top == -1;
}

// 判断栈是否已满
bool IsFull(Stack *S) {
    return S->top == MAXSIZE - 1;
}

// 入栈
bool Push(Stack *S, char c) {
    if (IsFull(S)) {
        return false;
    }
    S->data[++S->top] = c;
    return true;
}

// 出栈
bool Pop(Stack *S, char *c) {
    if (IsEmpty(S)) {
        return false;
    }
    *c = S->data[S->top--];
    return true;
}

// 获取栈顶元素
bool GetTop(Stack *S, char *c) {
    if (IsEmpty(S)) {
        return false;
    }
    *c = S->data[S->top];
    return true;
}

// 判断是否为左括号
bool IsLeft(char c) {
    return c == '(' || c == '[' || c == '{';
}

// 判断是否为右括号
bool IsRight(char c) {
    return c == ')' || c == ']' || c == '}';
}

// 判断左右括号是否匹配
bool IsMatch(char left, char right) {
    return (left == '(' && right == ')')
        || (left == '[' && right == ']')
        || (left == '{' && right == '}');
}

// 判断括号序列是否匹配
bool IsParenthesesMatch(char *str) {
    Stack S;
    InitStack(&S);

    for (int i = 0; str[i] != '\0'; i++) {
        if (IsLeft(str[i])) {
            // 左括号入栈
            Push(&S, str[i]);
        } else if (IsRight(str[i])) {
            // 右括号与栈顶元素匹配则出栈
            char top;
            if (!Pop(&S, &top) || !IsMatch(top, str[i])) {
                return false;
            }
        }
    }

    // 括号序列匹配当且仅当栈为空
    return IsEmpty(&S);
}

int main() {
    char str[MAXSIZE];
    printf("请输入括号序列：");
    scanf("%s", str);

    if (IsParenthesesMatch(str)) {
        printf("括号序列匹配\n");
    } else {
        printf("括号序列不匹配\n");
    }

    return 0;
}

代码的思路是：遍历括号序列，若是左括号则入栈，若是右括号则与栈顶元素匹配，若匹配则将栈顶元素出栈，否则返回不匹配。最后判断栈是否为空，若为空则括号序列匹配，否则不匹配。