1，实现深度优先搜索算法。
以下是使用 C 语言实现深度优先搜索算法的示例代码：
#include
#include
#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
#include
#include
#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
#include
// 定义链表节点
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
#include
// 定义二叉树节点
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
// 交换数组中两个元素的位置
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;
}