C语言经典面试题目（十五）

1、如何在C语言中实现堆数据结构？

在C语言中，可以通过动态内存分配来实现堆数据结构。一种常见的方式是使用数组来表示堆，并使用堆的性质来维护数组的结构。以下是一个简单的堆数据结构的示例：

#include 
#include 

#define MAX_HEAP_SIZE 100

typedef struct {
    int *elements;
    int size;
    int capacity;
} Heap;

Heap *createHeap(int capacity) {
    Heap *heap = (Heap *)malloc(sizeof(Heap));
    heap->elements = (int *)malloc(sizeof(int) * (capacity + 1));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(Heap *heap, int index) {
    while (index > 1 && heap->elements[index] > heap->elements[index / 2]) {
        swap(&heap->elements[index], &heap->elements[index / 2]);
        index /= 2;
    }
}

void heapifyDown(Heap *heap, int index) {
    int largest = index;
    int left = 2 * index;
    int right = 2 * index + 1;
    
    if (left <= heap->size && heap->elements[left] > heap->elements[largest]) {
        largest = left;
    }
    if (right <= heap->size && heap->elements[right] > heap->elements[largest]) {
        largest = right;
    }
    if (largest != index) {
        swap(&heap->elements[index], &heap->elements[largest]);
        heapifyDown(heap, largest);
    }
}

void insert(Heap *heap, int value) {
    if (heap->size >= heap->capacity) {
        printf("Heap is full\n");
        return;
    }
    heap->elements[++(heap->size)] = value;
    heapifyUp(heap, heap->size);
}

int removeMax(Heap *heap) {
    if (heap->size == 0) {
        printf("Heap is empty\n");
        return -1;
    }
    int maxValue = heap->elements[1];
    heap->elements[1] = heap->elements[heap->size--];
    heapifyDown(heap, 1);
    return maxValue;
}

void printHeap(Heap *heap) {
    for (int i = 1; i <= heap->size; i++) {
        printf("%d ", heap->elements[i]);
    }
    printf("\n");
}

int main() {
    Heap *heap = createHeap(MAX_HEAP_SIZE);
    insert(heap, 10);
    insert(heap, 5);
    insert(heap, 15);
    insert(heap, 20);
    printHeap(heap); // 输出：20 10 15 5
    printf("Max value removed: %d\n", removeMax(heap)); // 输出：Max value removed: 20
    printHeap(heap); // 输出：15 10 5
    return 0;
}

2、C语言中的标准输入输出函数有哪些？请列举几个常用的标准输入输出函数。

C语言中常用的标准输入输出函数包括：

1. printf：用于向标准输出流（stdout）打印输出。
2. scanf：用于从标准输入流（stdin）读取输入。
3. getchar：用于从标准输入流中读取一个字符。
4. putchar：用于向标准输出流中输出一个字符。
5. gets：用于从标准输入流中读取一行字符串。
6. puts：用于向标准输出流中输出一行字符串。

3、C语言中的函数调用过程是怎样的？请解释函数调用栈的作用。

函数调用过程是指在程序执行过程中，函数被调用时所发生的一系列操作，包括参数传递、栈帧的创建、函数执行和返回值的传递等。

函数调用栈是用来管理函数调用过程的数据结构，通常是一个后进先出（LIFO）的栈。每次函数调用时，会在栈上创建一个新的栈帧（activation record），用于存储函数的局部变量、参数值和返回地址等信息。当函数执行完毕时，对应的栈帧会被弹出，控制权返回到调用函数处。

函数调用栈的作用包括：

1. 存储函数调用的信息：每次函数调用时，函数的相关信息会被存储在栈帧中，包括参数值、局部变量、返回地址等。
2. 管理函数的执行顺序：函数调用栈按照后进先出的顺序管理函数的调用顺序，保证函数执行的顺序正确。
3. 支持递归调用：函数调用栈的特性使得递归函数调用成为可能，每次递归调用都会在栈上创建一个新的栈帧。

4、如何在C语言中实现动态数组数据结构？

在C语言中，可以通过动态内存分配来实现动态数组。一种常见的方式是使用指针和malloc函数来动态分配内存，并使用realloc函数来调整数组大小。以下是一个简单的动态数组的示例：

#include 
#include 

#define INITIAL_CAPACITY 10

typedef struct {
    int *array;
    int size;
    int capacity;
} DynamicArray;

DynamicArray *createDynamicArray() {
    DynamicArray *dynArray = (DynamicArray *)malloc(sizeof(DynamicArray));
    dynArray->array = (int *)malloc(sizeof(int) * INITIAL_CAPACITY);
    dynArray->size = 0;
    dynArray->capacity = INITIAL_CAPACITY;
    return dynArray;
}

void resize(DynamicArray *dynArray, int newCapacity) {
    dynArray->array = (int *)realloc(dynArray->array, sizeof(int) * newCapacity);
    dynArray->capacity = newCapacity;
}

void append(DynamicArray *dynArray, int value) {
    if (dynArray->size >= dynArray->capacity) {
        resize(dynArray, dynArray->capacity * 2);
    }
    dynArray->array[dynArray->size++] = value;
}

void printDynamicArray(DynamicArray *dynArray) {
    for (int i = 0; i < dynArray->size; i++) {
        printf("%d ", dynArray->array[i

]);
    }
    printf("\n");
}

int main() {
    DynamicArray *dynArray = createDynamicArray();
    for (int i = 0; i < 20; i++) {
        append(dynArray, i);
    }
    printDynamicArray(dynArray); // 输出：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
    free(dynArray->array);
    free(dynArray);
    return 0;
}

5、C语言中的信号处理函数有哪些？请列举几个常用的信号处理函数。

C语言中常用的信号处理函数包括：

1. signal：用于设置信号的处理函数。
2. kill：向指定进程发送信号。
3. raise：向当前进程发送信号。
4. abort：向当前进程发送SIGABRT信号，导致程序异常终止。

以下是一个简单的示例，演示了如何使用signal函数设置信号的处理函数：

#include 
#include 
#include 

void signalHandler(int signum) {
    printf("Received signal %d\n", signum);
}

int main() {
    signal(SIGINT, signalHandler); // 设置SIGINT信号的处理函数为signalHandler
    printf("Waiting for SIGINT signal...\n");
    while (1) {
        // 死循环等待信号
    }
    return 0;
}

在上面的示例中，当接收到SIGINT信号（Ctrl+C）时，将调用signalHandler函数进行处理。