c语言编程题经典100例——（36~40例）

1，实现快速排序算法。

下面是用C语言实现快速排序算法的示例代码：

#include   
  
void swap(int* a, int* b) {  
    int t = *a;  
    *a = *b;  
    *b = t;  
}  
  
int partition(int arr[], int low, int high) {  
    int pivot = arr[high];  
    int i = (low - 1);  
    for (int j = low; j <= high - 1; j++) {  
        if (arr[j] < pivot) {  
            i++;  
            swap(&arr[i], &arr[j]);  
        }  
    }  
    swap(&arr[i + 1], &arr[high]);  
    return (i + 1);  
}  
  
void quickSort(int arr[], int low, int high) {  
    if (low < high) {  
        int pi = partition(arr, low, high);  
        quickSort(arr, low, pi - 1);  
        quickSort(arr, pi + 1, high);  
    }  
}  
  
int main() {  
    int arr[] = {10, 7, 8, 9, 1, 5};  
    int n = sizeof(arr) / sizeof(arr[0]);  
    quickSort(arr, 0, n - 1);  
    printf("Sorted array: ");  
    for (int i = 0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    return 0;  
}

        快速排序算法的基本思想是，选择一个基准元素，将数组划分为两个子数组，左边的元素小于基准元素，右边的元素大于基准元素，然后递归地对左右两个子数组进行排序。在实现中，partition函数用来划分数组，并返回基准元素的最终位置。quickSort函数用来递归地排序左右两个子数组。

2，实现归并排序算法。

以下是C语言实现归并排序算法的示例代码：

#include   
  
void merge(int arr[], int left[], int right[], int left_size, int right_size) {  
    int i, j, k;  
    i = j = k = 0;  
  
    while (i < left_size && j < right_size) {  
        if (left[i] <= right[j]) {  
            arr[k++] = left[i++];  
        } else {  
            arr[k++] = right[j++];  
        }  
    }  
  
    while (i < left_size) {  
        arr[k++] = left[i++];  
    }  
  
    while (j < right_size) {  
        arr[k++] = right[j++];  
    }  
}  
  
void mergeSort(int arr[], int n) {  
    if (n < 2) {  
        return;  
    }  
  
    int mid = n / 2;  
    int left[mid], right[n - mid];  
  
    for (int i = 0; i < mid; i++) {  
        left[i] = arr[i];  
    }  
  
    for (int i = mid; i < n; i++) {  
        right[i - mid] = arr[i];  
    }  
  
    mergeSort(left, mid);  
    mergeSort(right, n - mid);  
    merge(arr, left, right, mid, n - mid);  
}  
  
int main() {  
    int arr[] = {10, 7, 8, 9, 1, 5};  
    int n = sizeof(arr) / sizeof(arr[0]);  
    mergeSort(arr, n);  
    printf("Sorted array: ");  
    for (int i = 0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    return 0;  
}

在这个示例代码中，merge函数将两个有序数组（left和right）合并为一个有序数组（arr）。mergeSort函数将整个数组分成两个子数组，递归地对它们进行排序，然后将它们合并。在主函数中，我们首先声明一个整数数组，然后计算它的大小，最后调用mergeSort函数对其进行排序。

3，实现链表中的两个节点之间的距离。

在链表中，两个节点之间的距离可以通过遍历链表并计算节点之间的差距来计算。以下是一种C语言实现的方式。

首先，我们需要定义链表节点的结构体：

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

然后，我们可以定义一个函数来计算两个节点之间的距离：

int getDistance(struct Node* head, int x, int y) {  
    struct Node* ptr1 = head;  
    struct Node* ptr2 = head;  
    int distance = 0;  
    while(ptr1 != NULL && ptr2 != NULL) {  
        if(ptr1->data == x) {  
            ptr2 = ptr2->next;  
        } else {  
            ptr1 = ptr1->next;  
        }  
        if(ptr2 != NULL && ptr2->data == y) {  
            distance++;  
            ptr2 = ptr2->next;  
        } else {  
            ptr2 = ptr2->next;  
        }  
    }  
    return distance;  
}

        在上述代码中，我们使用两个指针 ptr1 和 ptr2 来遍历链表。指针 ptr1 用于寻找节点 x，而指针 ptr2 用于寻找节点 y。如果在遍历过程中找到 x，则我们将 ptr2 移动到下一个节点。如果在遍历过程中找到 y，则我们增加距离并移动 ptr2 到下一个节点。否则，我们继续移动 ptr1 和 ptr2 到下一个节点。当 ptr1 或 ptr2 到达链表的末尾时，我们就停止遍历。最后，返回的距离就是两个节点之间的距离。

请注意，这个函数假设 x 和 y 是存在于链表中的实际值，并且它返回的是这两个值之间的最短距离。如果链表中不存在这些值，或者如果它们不存在于同一个链表中，那么函数将返回0。

4，实现循环队列。

以下是用C语言实现循环队列的示例代码：

#include   
#include   
  
#define MAX_SIZE 5  
  
typedef struct {  
    int data[MAX_SIZE];  
    int front;  
    int rear;  
} Queue;  
  
void initQueue(Queue *q) {  
    q->front = 0;  
    q->rear = 0;  
}  
  
int isQueueEmpty(Queue *q) {  
    return (q->front == q->rear);  
}  
  
int isQueueFull(Queue *q) {  
    return ((q->rear + 1) % MAX_SIZE == q->front);  
}  
  
void enqueue(Queue *q, int x) {  
    if (isQueueFull(q)) {  
        printf("Queue is full.\n");  
        return;  
    }  
    q->data[q->rear] = x;  
    q->rear = (q->rear + 1) % MAX_SIZE;  
}  
  
int dequeue(Queue *q) {  
    int x;  
    if (isQueueEmpty(q)) {  
        printf("Queue is empty.\n");  
        exit(0);  
    }  
    x = q->data[q->front];  
    q->front = (q->front + 1) % MAX_SIZE;  
    return x;  
}  
  
void printQueue(Queue *q) {  
    if (isQueueEmpty(q)) {  
        printf("Queue is empty.\n");  
        return;  
    }  
    printf("Queue elements: ");  
    int i = q->front;  
    while (i != q->rear) {  
        printf("%d ", q->data[i]);  
        i = (i + 1) % MAX_SIZE;  
    }  
    printf("\n");  
}  
  
int main() {  
    Queue q;  
    initQueue(&q);  
    enqueue(&q, 10);  
    enqueue(&q, 20);  
    enqueue(&q, 30);  
    printQueue(&q);  
    printf("Dequeue element: %d\n", dequeue(&q));  
    printQueue(&q);  
    enqueue(&q, 40);  
    enqueue(&q, 50);  
    printQueue(&q);  
    enqueue(&q, 60);  
    printf("Dequeue element: %d\n", dequeue(&q));  
    printf("Dequeue element: %d\n", dequeue(&q));  
    printf("Dequeue element: %d\n", dequeue(&q));  
    printf("Dequeue element: %d\n", dequeue(&q));  
    printf("Dequeue element: %d\n", dequeue(&q));  
    return 0;  
}

5，实现静态数组的排序算法（冒泡排序、插入排序等）。

这里是使用 C 语言实现静态数组排序算法（冒泡排序和插入排序）的示例代码。

冒泡排序：

#include   
  
void bubbleSort(int arr[], int n) {  
    int i, j, temp;  
    for (i = 0; i < n-1; i++) {  
        for (j = 0; j < n-i-1; j++) {  
            if (arr[j] > arr[j+1]) {  
                temp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = temp;  
            }  
        }  
    }  
}  
  
int main() {  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int n = sizeof(arr)/sizeof(arr[0]);  
    bubbleSort(arr, n);  
    printf("Sorted array: \n");  
    for(int i=0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    return 0;  
}

插入排序：

#include   
  
void insertionSort(int arr[], int n) {  
    int i, key, j;  
    for (i = 1; i < n; i++) {  
        key = arr[i];  
        j = i - 1;  
        while (j >= 0 && arr[j] > key) {  
            arr[j+1] = arr[j];  
            j = j - 1;  
        }  
        arr[j+1] = key;  
    }  
}  
  
int main() {  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int n = sizeof(arr)/sizeof(arr[0]);  
    insertionSort(arr, n);  
    printf("Sorted array: \n");  
    for(int i=0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    return 0;  
}

这两个算法都是对静态数组进行排序的基础算法。在 main 函数中，我们定义了一个静态数组，并对其进行排序，然后输出排序后的数组。