如何在C语言中用.empty

在C语言中，并没有直接提供`.empty`这样的成员函数用于检查容器是否为空，因为C语言本身并不是一种支持复杂数据结构的语言，如数组、链表等需要用户手动管理内存和状态。如果你想检查数组是否为空，可以简单地检查数组的第一个元素是否为NULL或者其他特定值。

例如，如果你有一个动态分配的一维整型数组：

int *array = malloc(sizeof(int) * n); // 分配n个int的空间

if (array == NULL) {
    printf("Array is empty.\n");
} else if (array[0] == 0 || array[0] == some_initial_value) {
    printf("Array is empty or has a default value.\n");
}

对于更复杂的容器，如链表，你需要遍历节点直到找到最后一个节点或者遇到空节点：

struct Node* head = ...; // 链表头指针

if (head == NULL || head->next == NULL) {
    printf("List is empty.\n");
}

相关问题

在C语言中用堆栈实现汉诺塔求解问题

下面是用堆栈实现汉诺塔问题的C语言代码：

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

#define MAX_SIZE 20

// 定义结构体表示栈
typedef struct {
    int top;
    int data[MAX_SIZE];
} 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, int x) {
    if (is_full(s)) {
        printf("Stack overflow.\n");
        exit(1);
    }
    s->data[++s->top] = x;
}

// 出栈操作
int pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow.\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 汉诺塔递归函数
void hanoi(int n, char a, char b, char c, Stack *s) {
    if (n == 1) {
        printf("Move disk 1 from %c to %c\n", a, c);
        push(s, 1);
        return;
    }
    hanoi(n - 1, a, c, b, s);
    int x = pop(s) + 1;
    printf("Move disk %d from %c to %c\n", x, a, c);
    push(s, x);
    hanoi(n - 1, b, a, c, s);
}

int main() {
    int n;
    printf("Enter the number of disks: ");
    scanf("%d", &n);
    Stack s;
    init(&s);
    hanoi(n, 'A', 'B', 'C', &s);
    return 0;
}

在这个代码中，我们定义了一个结构体 `Stack` 表示栈，其中包括一个整数 `top` 表示栈顶位置和一个整型数组 `data` 作为栈的数据区。

我们用 `init` 函数初始化栈，用 `is_empty` 和 `is_full` 函数判断栈是否为空或已满，用 `push` 函数将元素入栈，用 `pop` 函数将元素出栈。

在 `hanoi` 函数中，我们使用递归来实现汉诺塔问题。如果有一个盘子，我们直接将它从 A 移动到 C，并将它压入栈中。如果有多个盘子，我们先将前 n-1 个盘子从 A 移动到 B，再将最后一个盘子从 A 移动到 C，最后将前 n-1 个盘子从 B 移动到 C。在移动每个盘子的时候，我们要记录它的编号，因为我们需要用栈来记录移动的顺序。

在 `main` 函数中，我们初始化了一个栈，然后调用 `hanoi` 函数来解决汉诺塔问题。

在c语言中用栈十进制转二进制

可以通过以下代码实现：

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

#define MAX_CHAR 100

// 定义栈结构
typedef struct {
    int top;  // 栈顶指针
    int capacity;  // 栈的容量
    int *arr;  // 存储元素的数组指针
} Stack;

// 初始化栈
Stack *initStack(int capacity) {
    Stack *stack = (Stack *)malloc(sizeof(Stack));
    stack->top = -1;
    stack->capacity = capacity;
    stack->arr = (int *)malloc(sizeof(int) * capacity);
    return stack;
}

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

// 判断栈是否已满
bool isFull(Stack *stack) {
    return stack->top == stack->capacity - 1;
}

// 入栈
void push(Stack *stack, int data) {
    if (isFull(stack)) {
        printf("Stack is full.\n");
        return;
    }
    stack->top++;
    stack->arr[stack->top] = data;
}

// 出栈
int pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty.\n");
        return -1;
    }
    int data = stack->arr[stack->top];
    stack->top--;
    return data;
}

// 十进制转二进制
void decimalToBinary(int decimal) {
    Stack *stack = initStack(MAX_CHAR);
    while (decimal > 0) {
        push(stack, decimal % 2);  // 余数入栈
        decimal /= 2;
    }
    printf("Binary representation is: ");
    while (!isEmpty(stack)) {
        printf("%d", pop(stack));  // 依次出栈输出
    }
    printf("\n");
}

int main() {
    int decimal;
    printf("Input a decimal number: ");
    scanf("%d", &decimal);
    decimalToBinary(decimal);
    return 0;
}

代码中用到了栈结构，通过一次次的除以二，将每次的余数依次入栈，再依次出栈输出，从而实现了十进制转二进制。