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;
}