c语言编程题经典100例——（31~35例）

十启树2023-11-27 16:33

1，实现深度优先搜索算法。

以下是使用 C 语言实现深度优先搜索算法的示例代码：

#include <stdio.h>  
#include <stdbool.h>  
  
#define MAX_VERTICES 100  
  
// 图的最大顶点数  
  
// 图的邻接表表示  
typedef struct {  
    int edges[MAX_VERTICES][MAX_VERTICES];  
    int n; // 顶点数  
} Graph;  
  
// 初始化图  
void initGraph(Graph *g, int n) {  
    g->n = n;  
    for (int i = 0; i < n; i++) {  
        for (int j = 0; j < n; j++) {  
            g->edges[i][j] = -1; // 无边用-1表示  
        }  
    }  
}  
  
// 添加边  
void addEdge(Graph *g, int u, int v) {  
    g->edges[u][v] = 1; // 有边用1表示  
    g->edges[v][u] = 1; // 无向图需要添加双向边  
}  
  
// 深度优先搜索算法  
void dfs(Graph *g, int v, bool visited[]) {  
    visited[v] = true; // 标记当前顶点已被访问过  
    printf("%d ", v); // 输出当前顶点编号  
    for (int i = 0; i < g->n; i++) {  
        if (g->edges[v][i] == 1 && !visited[i]) { // 如果当前顶点与下一个顶点之间有边且下一个顶点未被访问过，则继续搜索下一个顶点  
            dfs(g, i, visited);  
        }  
    }  
}  
  
int main() {  
    Graph g; // 定义一个图结构体变量  
    initGraph(&g, 6); // 初始化图  
    addEdge(&g, 0, 1); // 添加边  
    addEdge(&g, 0, 2);  
    addEdge(&g, 1, 3);  
    addEdge(&g, 2, 3);  
    addEdge(&g, 3, 4);  
    addEdge(&g, 3, 5);  
    bool visited[MAX_VERTICES]; // 标记每个顶点是否被访问过，初始值为false  
    for (int i = 0; i < g.n; i++) { // 初始化visited数组为false  
        visited[i] = false;  
    }  
    printf("DFS顺序："); // 输出深度优先搜索的结果  
    dfs(&g, 0, visited); // 从顶点0开始进行深度优先搜索  
    printf("\n");  
    return 0;  
}

该代码中，Graph结构体表示一个无向图，使用邻接表表示。initGraph函数用于初始化图，addEdge函数用于添加边，dfs函数实现了深度优先搜索算法。在main函数中，首先初始化图，然后标记每个顶点是否被访问过，最后从顶点0开始进行深度优先搜索并输出搜索结果。

2，实现广度优先搜索算法。

以下是使用C语言实现广度优先搜索算法的示例代码：

#include <stdio.h>  
#include <stdlib.h>  
#include <stdbool.h>  
  
#define MAX_VERTICES 100  
  
// 图的最大顶点数  
  
// 图的邻接表表示  
typedef struct {  
    int edges[MAX_VERTICES][MAX_VERTICES];  
    int n; // 顶点数  
} Graph;  
  
// 初始化图  
void initGraph(Graph *g, int n) {  
    g->n = n;  
    for (int i = 0; i < n; i++) {  
        for (int j = 0; j < n; j++) {  
            g->edges[i][j] = -1; // 无边用-1表示  
        }  
    }  
}  
  
// 添加边  
void addEdge(Graph *g, int u, int v) {  
    g->edges[u][v] = 1; // 有边用1表示  
    g->edges[v][u] = 1; // 无向图需要添加双向边  
}  
  
// 广度优先搜索算法  
void bfs(Graph *g, int start) {  
    int queue[MAX_VERTICES]; // 队列用于存储待访问的顶点编号  
    int front = 0, rear = 0; // 队列的前队和后队指针  
    bool visited[MAX_VERTICES]; // 标记每个顶点是否被访问过，初始值为false  
    for (int i = 0; i < g->n; i++) { // 初始化visited数组为false  
        visited[i] = false;  
    }  
    visited[start] = true; // 将起始顶点标记为已访问过  
    printf("%d ", start); // 输出起始顶点编号  
    queue[rear++] = start; // 将起始顶点加入队列  
    while (front < rear) { // 当队列不为空时，依次取出队首元素并访问其相邻顶点  
        int v = queue[front++]; // 取出队首元素v  
        for (int i = 0; i < g->n; i++) { // 遍历v的所有相邻顶点i  
            if (g->edges[v][i] == 1 && !visited[i]) { // 如果顶点i与v之间有边且未被访问过，则将其标记为已访问过并加入队列中  
                printf("%d ", i); // 输出顶点i的编号  
                visited[i] = true; // 将顶点i标记为已访问过  
                queue[rear++] = i; // 将顶点i加入队列中  
            }  
        }  
    }  
}  
  
int main() {  
    Graph g; // 定义一个图结构体变量  
    initGraph(&g, 6); // 初始化图  
    addEdge(&g, 0, 1); // 添加边  
    addEdge(&g, 0, 2);
    addEdge(&g, 0, 3);
    addEdge(&g, 0, 4);
    addEdge(&g, 0, 5);
    addEdge(&g, 0, 6);
}

3，实现链表的操作（插入、删除、反转等）。

以下是一个使用 C 语言实现链表操作的基本示例。我们将创建一个简单的链表结构，并实现插入、删除和反转功能。

#include <stdio.h>  
#include <stdlib.h>  
  
// 定义链表节点  
struct Node {  
    int data;  
    struct Node* next;  
};  
  
// 插入节点至链表末尾  
void insertNode(struct Node** head, int data) {  
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));  
    newNode->data = data;  
    newNode->next = NULL;  
      
    if (*head == NULL) { // 如果链表为空，新节点为头节点  
        *head = newNode;  
        return;  
    }  
      
    struct Node* temp = *head;  
    while (temp->next != NULL) { // 遍历找到链表的末尾  
        temp = temp->next;  
    }  
    temp->next = newNode; // 将新节点插入链表末尾  
}  
  
// 删除指定数据的节点  
void deleteNode(struct Node** head, int data) {  
    if (*head == NULL) { // 如果链表为空，直接返回  
        return;  
    }  
      
    if ((*head)->data == data) { // 如果头节点就是要删除的节点  
        struct Node* temp = *head;  
        *head = (*head)->next; // 删除头节点，并更新头指针  
        free(temp); // 释放旧的头节点的内存  
        return;  
    }  
      
    struct Node* temp = *head;  
    while (temp->next != NULL && temp->next->data != data) { // 遍历找到要删除的节点的前一个节点  
        temp = temp->next;  
    }  
    if (temp->next != NULL) { // 如果找到了要删除的节点，删除并更新前一个节点的next指针  
        struct Node* toDelete = temp->next;  
        temp->next = temp->next->next; // 删除节点，并更新前一个节点的next指针  
        free(toDelete); // 释放被删除节点的内存  
    }  
}  
  
// 反转链表  
void reverseList(struct Node** head) {  
    struct Node* prev = NULL;  
    struct Node* current = *head;  
    struct Node* next = NULL;  
    while (current != NULL) { // 遍历链表，逐个反转节点的next指针方向  
        next = current->next; // 暂时保存下一个节点，因为反转后current节点的next会变为NULL，无法再访问下一个节点了。  
        current->next = prev; // 将当前节点的next指向前一个节点，完成反转。  
        prev = current; // 移动prev和current节点，继续下一个循环。  
        current = next; // 移动current节点。  
    }  
    *head = prev; // 将反转后的链表的头节点设置为prev，因为原先的头节点已经变成了反转后的最后一个节点。  
}
复制代码

4，实现二叉树的操作（遍历、查找等）。

以下是使用 C 语言实现二叉树的基本操作（遍历、查找等）的示例代码：

#include <stdio.h>  
#include <stdlib.h>  
  
// 定义二叉树节点  
struct Node {  
    int data;  
    struct Node* left;  
    struct Node* right;  
};  
  
// 创建新节点  
struct Node* createNode(int data) {  
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));  
    newNode->data = data;  
    newNode->left = NULL;  
    newNode->right = NULL;  
    return newNode;  
}  
  
// 插入节点至二叉树中  
void insertNode(struct Node** root, int data) {  
    if (*root == NULL) { // 如果二叉树为空，创建新节点作为根节点  
        *root = createNode(data);  
        return;  
    }  
    if (data < (*root)->data) { // 如果要插入的数据比根节点小，插入到左子树中  
        insertNode(&((*root)->left), data);  
    } else { // 否则，插入到右子树中  
        insertNode(&((*root)->right), data);  
    }  
}  
  
// 中序遍历二叉树（左子树-根节点-右子树）  
void inorderTraversal(struct Node* root) {  
    if (root != NULL) { // 如果节点不为空，先遍历左子树  
        inorderTraversal(root->left);  
        printf("%d ", root->data); // 访问根节点数据  
        inorderTraversal(root->right); // 再遍历右子树  
    }  
}  
  
// 二分查找（左边界-查找数据-右边界）是否存在于二叉搜索树中  
int binarySearch(struct Node* root, int target) {  
    int left = 0; // 左边界为0（最小值）  
    int right = 100000; // 右边界为100000（最大值）  
    while (left <= right) { // 当左边界小于等于右边界时，继续查找  
        int mid = (left + right) / 2; // 中间值为mid（取整）  
        if (root == NULL || root->data == target) { // 如果二叉树为空或者找到了目标数据，返回对应的索引值（0表示找到了，-1表示未找到）  
            return root == NULL ? 0 : -1;  
        } else if (root->data < target) { // 如果当前节点的值小于目标数据，将左边界更新为mid+1，继续在右子树中查找  
            left = mid + 1;  
        } else { // 否则，将右边界更新为mid-1，继续在左子树中查找  
            right = mid - 1;  
        }  
    }  
    return -1; // 在二叉搜索树中未找到目标数据，返回-1表示未找到。  
}

5，实现堆排序算法。

以下是使用C语言实现堆排序算法的示例代码：

#include <stdio.h>  
  
// 交换数组中两个元素的位置  
void swap(int* arr, int i, int j) {  
    int temp = arr[i];  
    arr[i] = arr[j];  
    arr[j] = temp;  
}  
  
// 调整堆，使其满足堆的性质  
void heapify(int* arr, int n, int i) {  
    int largest = i; // 初始化根节点索引为最大值  
    int left = 2 * i + 1; // 左子节点索引  
    int right = 2 * i + 2; // 右子节点索引  
  
    // 如果左子节点比根节点大，则更新最大值索引  
    if (left < n && arr[left] > arr[largest]) {  
        largest = left;  
    }  
  
    // 如果右子节点比最大值索引对应的值大，则更新最大值索引  
    if (right < n && arr[right] > arr[largest]) {  
        largest = right;  
    }  
  
    // 如果最大值索引不是根节点，则交换根节点和最大值索引对应的值，并递归调整子树  
    if (largest != i) {  
        swap(arr, i, largest);  
        heapify(arr, n, largest);  
    }  
}  
  
// 堆排序函数  
void heapSort(int* arr, int n) {  
    // 构建最大堆（从最后一个非叶子节点开始）  
    for (int i = n / 2 - 1; i >= 0; i--) {  
        heapify(arr, n, i);  
    }  
  
    // 从最后一个元素开始，依次将最大元素与当前元素交换，并调整堆  
    for (int i = n - 1; i >= 0; i--) {  
        swap(arr, 0, i);  
        heapify(arr, i, 0);  
    }  
}  
  
int main() {  
    int arr[] = {5, 3, 8, 4, 2, 1, 9, 7, 6}; // 待排序数组  
    int n = sizeof(arr) / sizeof(arr[0]); // 数组长度  
  
    heapSort(arr, n); // 排序  
  
    printf("排序结果：");  
    for (int i = 0; i < n; i++) {  
        printf("%d ", arr[i]); // 输出排序结果  
    }  
    printf("\n");  
    return 0;  
}
相关推荐
敲敲敲-敲代码7 分钟前
游戏设计：推箱子【easyx图形界面/c语言】
c语言·开发语言·游戏
ROC_bird..15 分钟前
STL - vector的使用和模拟实现
开发语言·c++
MavenTalk21 分钟前
Move开发语言在区块链的开发与应用
开发语言·python·rust·区块链·solidity·move
simple_ssn29 分钟前
【C语言刷力扣】1502.判断能否形成等差数列
c语言·算法·leetcode
ahadee1 小时前
蓝桥杯每日真题 - 第10天
c语言·vscode·算法·蓝桥杯
XiaoLeisj1 小时前
【JavaEE初阶 — 多线程】生产消费模型 & 阻塞队列
java·开发语言·java-ee
2401_840192271 小时前
python基础大杂烩
linux·开发语言·python
@东辰1 小时前
【golang-技巧】- 定时任务 - cron
开发语言·golang·cron
机器人天才一号1 小时前
C#从入门到放弃
开发语言·c#
好想有猫猫1 小时前
【51单片机】LCD1602液晶显示屏
c语言·单片机·嵌入式硬件·51单片机·1024程序员节
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化