当前位置： 首页 > article >正文

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

article 2024/11/6 0:36:42

1，实现快速排序算法。

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

#include <stdio.h>  
  
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 <stdio.h>  
  
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 <stdio.h>  
#include <stdlib.h>  
  
#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 <stdio.h>  
  
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 <stdio.h>  
  
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 函数中，我们定义了一个静态数组，并对其进行排序，然后输出排序后的数组。


http://www.kler.cn/a/150130.html

相关文章：

  • centos7 kafka高可用集群安装及测试
  • FFmpeg 4.3 音视频-多路H265监控录放C++开发十二：在屏幕上显示多路视频播放，可以有不同的分辨率，格式和帧率。
  • Python并发编程库：Asyncio的异步编程实战
  • 【系统架构设计师】2023年真题论文: 论面向对象分析的应用与实现（包括解题思路和素材）
  • ubantu lnmp
  • 「Mac畅玩鸿蒙与硬件17」鸿蒙UI组件篇7 - Animation 组件基础
  • Es6笔记之箭头函数与解构赋值
  • Day60.算法训练
  • 基于C#实现Prim算法
  • 不同路径 II（力扣LeetCode）动态规划
  • 荒野大镖客提示找不到emp.dll文件的5个修复方法-快速修复dll教程
  • ZYNQ_project:lcd_pic_400x400
  • springboot 返回problem+json
  • 【云备份】第三方库的认识与使用
  • go模版引擎的使用~~
  • 【c语言】二维数组的对角线对称交换
  • LeetCode 60. 排列序列【数学,逆康托展开】困难
  • ⑤【Sorted Set】Redis常用数据类型： ZSet [使用手册]
  • WordPress更改文章分类插件
  • CH01_适应设计模式
  • 网络安全如何自学？
  • 深圳市东星制冷机电受邀莅临2024国际生物发酵展，济南与您相约
  • Spring的依赖注入,依赖注入的基本原则，依赖注入的优势
  • 【Vulnhub 靶场】【Coffee Addicts: 1】【简单-中等】【20210520】
  • 01_原理-事件循环
  • docker （简介、dcoker详细安装步骤、容器常用命令）一站打包- day01