案例一：Hello World程序
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
这是一个最基础的C语言程序，用于输出“Hello, World!”。通过这个案例，我们可以学习到C语言的基本结构，包括头文件、主函数和输出语句。
案例二：变量和赋值
#include <stdio.h>
int main() {
int age = 20;
printf("My age is: %d\n", age);
return 0;
}
在这个案例中，我们学习了如何定义变量并为其赋值。通过输出变量的值，我们可以了解C语言中变量的使用方法。
案例三：数据类型
#include <stdio.h>
int main() {
int num = 10;
float fnum = 3.14;
char letter = 'A';
printf("Integer: %d\n", num);
printf("Float: %f\n", fnum);
printf("Character: %c\n", letter);
return 0;
}
这个案例展示了C语言中的不同数据类型，包括整数、浮点数和字符。通过输出不同数据类型的值，我们可以了解它们的特点和用法。
案例四：运算符
#include <stdio.h>
int main() {
int a = 5, b = 3;
printf("Addition: %d\n", a + b);
printf("Subtraction: %d\n", a - b);
printf("Multiplication: %d\n", a * b);
printf("Division: %d\n", a / b);
printf("Modulus: %d\n", a % b);
return 0;
}
在这个案例中，我们学习了C语言中的基本运算符，包括加、减、乘、除和取模。通过计算不同运算符的结果，我们可以了解它们的运算规则。
案例五：条件语句
#include <stdio.h>
int main() {
int num = 10;
if (num > 5) {
printf("The number is greater than 5.\n");
} else {
printf("The number is not greater than 5.\n");
}
return 0;
}
这个案例展示了C语言中的条件语句，用于根据条件判断执行不同的代码块。通过判断一个数的值，我们可以了解条件语句的用法。
案例六：循环语句
#include <stdio.h>
int main() {
int i;
for (i = 1; i <= 10; i++) {
printf("%d\n", i);
}
return 0;
}
在这个案例中，我们学习了C语言中的循环语句，包括for循环。通过输出1到10的数字，我们可以了解循环语句的用法。
案例七：数组
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
printf("The first number is: %d\n", numbers[0]);
printf("The last number is: %d\n", numbers[4]);
return 0;
}
这个案例展示了C语言中的数组，用于存储一系列相同类型的元素。通过访问数组的元素，我们可以了解数组的用法。
案例八：函数
#include <stdio.h>
void printMessage() {
printf("Hello, World!\n");
}
int main() {
printMessage();
return 0;
}
在这个案例中，我们学习了C语言中的函数，用于封装代码块并提高代码的可重用性。通过调用函数，我们可以了解函数的用法。
案例九：指针
#include <stdio.h>
int main() {
int num = 10;
int *ptr = #
printf("The value of num is: %d\n", num);
printf("The address of num is: %p\n", (void *)ptr);
printf("The value of ptr is: %d\n", *ptr);
return 0;
}
这个案例展示了C语言中的指针，用于存储变量的地址。通过操作指针，我们可以了解指针的用法。
案例十：结构体
#include <stdio.h>
struct Person {
char name[50];
int age;
};
int main() {
struct Person person;
strcpy(person.name, "John");
person.age = 25;
printf("Name: %s\n", person.name);
printf("Age: %d\n", person.age);
return 0;
}
在这个案例中，我们学习了C语言中的结构体，用于定义复杂的数据类型。通过创建结构体实例并访问其成员，我们可以了解结构体的用法。
案例十一：文件操作
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("Error opening file.\n");
return 1;
}
fprintf(file, "Hello, World!\n");
fclose(file);
return 0;
}
这个案例展示了C语言中的文件操作，包括打开、写入和关闭文件。通过操作文件，我们可以了解文件操作的用法。
案例十二：动态内存分配
#include <stdio.h>
#include <stdlib.h>
int main() {
int *numbers = (int *)malloc(5 * sizeof(int));
if (numbers == NULL) {
printf("Error allocating memory.\n");
return 1;
}
for (int i = 0; i < 5; i++) {
numbers[i] = i + 1;
}
for (int i = 0; i < 5; i++) {
printf("%d\n", numbers[i]);
}
free(numbers);
return 0;
}
这个案例展示了C语言中的动态内存分配，用于在运行时分配内存。通过分配和释放内存，我们可以了解动态内存分配的用法。
案例十三：字符串处理
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello";
char str2[50] = "World";
char result[100];
strcpy(result, str1);
strcat(result, str2);
printf("Concatenated string: %s\n", result);
return 0;
}
这个案例展示了C语言中的字符串处理，包括字符串复制、连接和比较。通过操作字符串，我们可以了解字符串处理的用法。
案例十四：输入输出
#include <stdio.h>
int main() {
int num;
printf("Enter a number: ");
scanf("%d", &num);
printf("You entered: %d\n", num);
return 0;
}
这个案例展示了C语言中的输入输出，包括从用户获取输入和输出结果。通过处理输入输出，我们可以了解输入输出的用法。
案例十五：指针数组
#include <stdio.h>
int main() {
char *names[] = {"Alice", "Bob", "Charlie"};
for (int i = 0; i < 3; i++) {
printf("%s\n", names[i]);
}
return 0;
}
这个案例展示了C语言中的指针数组，用于存储字符串指针。通过遍历指针数组，我们可以了解指针数组的用法。
案例十六：结构体数组
#include <stdio.h>
struct Person {
char name[50];
int age;
};
int main() {
struct Person people[3] = {
{"Alice", 25},
{"Bob", 30},
{"Charlie", 35}
};
for (int i = 0; i < 3; i++) {
printf("Name: %s, Age: %d\n", people[i].name, people[i].age);
}
return 0;
}
这个案例展示了C语言中的结构体数组，用于存储结构体实例。通过遍历结构体数组，我们可以了解结构体数组的用法。
案例十七：函数指针
#include <stdio.h>
void printMessage() {
printf("Hello, World!\n");
}
int main() {
void (*funcPtr)() = printMessage;
funcPtr();
return 0;
}
这个案例展示了C语言中的函数指针，用于指向函数。通过调用函数指针，我们可以了解函数指针的用法。
案例十八：递归函数
#include <stdio.h>
int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main() {
int num = 5;
printf("Factorial of %d is: %d\n", num, factorial(num));
return 0;
}
这个案例展示了C语言中的递归函数，用于计算阶乘。通过递归调用函数，我们可以了解递归函数的用法。
案例十九：链表
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void insert(struct Node **head, int data) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = *head;
*head = newNode;
}
void printList(struct Node *head) {
while (head != NULL) {
printf("%d ", head->data);
head = head->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
insert(&head, 1);
insert(&head, 2);
insert(&head, 3);
insert(&head, 4);
insert(&head, 5);
printList(head);
return 0;
}
这个案例展示了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 insert(struct Node **root, int data) {
if (*root == NULL) {
*root = createNode(data);
} else if (data < (*root)->data) {
insert(&((*root)->left), data);
} else {
insert(&((*root)->right), data);
}
}
void inorderTraversal(struct Node *root) {
if (root != NULL) {
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}
}
int main() {
struct Node *root = NULL;
insert(&root, 5);
insert(&root, 3);
insert(&root, 7);
insert(&root, 2);
insert(&root, 4);
insert(&root, 6);
insert(&root, 8);
inorderTraversal(root);
return 0;
}
这个案例展示了C语言中的树，用于存储一系列有序元素。通过插入和遍历树，我们可以了解树的用法。
案例二十一：图
#include <stdio.h>
#include <stdlib.h>
struct Graph {
int numVertices;
int **adjMatrix;
};
struct Graph *createGraph(int numVertices) {
struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph));
graph->numVertices = numVertices;
graph->adjMatrix = (int **)malloc(numVertices * sizeof(int *));
for (int i = 0; i < numVertices; i++) {
graph->adjMatrix[i] = (int *)malloc(numVertices * sizeof(int));
for (int j = 0; j < numVertices; j++) {
graph->adjMatrix[i][j] = 0;
}
}
return graph;
}
void addEdge(struct Graph *graph, int src, int dest) {
graph->adjMatrix[src][dest] = 1;
graph->adjMatrix[dest][src] = 1;
}
void printGraph(struct Graph *graph) {
for (int i = 0; i < graph->numVertices; i++) {
for (int j = 0; j < graph->numVertices; j++) {
printf("%d ", graph->adjMatrix[i][j]);
}
printf("\n");
}
}
int main() {
struct Graph *graph = createGraph(4);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 2, 3);
printGraph(graph);
return 0;
}
这个案例展示了C语言中的图，用于存储一系列无序元素。通过添加边和打印图，我们可以了解图的用法。
案例二十二：排序算法
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
}
}
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
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");
printArray(arr, n);
return 0;
}
这个案例展示了C语言中的排序算法，包括冒泡排序。通过排序数组并打印结果，我们可以了解排序算法的用法。
案例二十三：查找算法
#include <stdio.h>
int binarySearch(int arr[], int l, int r, int x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m] == x) {
return m;
} else if (arr[m] < x) {
l = m + 1;
} else {
r = m - 1;
}
}
return -1;
}
int main() {
int arr[] = {2, 3, 4, 10, 40};
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
int result = binarySearch(arr, 0, n - 1, x);
if (result == -1) {
printf("Element is not present in array.\n");
} else {
printf("Element is present at index %d.\n", result);
}
return 0;
}
这个案例展示了C语言中的查找算法，包括二分查找。通过查找数组中的元素并打印结果，我们可以了解查找算法的用法。
案例二十四：动态规划
#include <stdio.h>
int fibonacci(int n) {
if (n <= 1) {
return n;
}
int fib[n + 1];
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i <= n; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
return fib[n];
}
int main() {
int n = 9;
printf("Fibonacci of %d is: %d\n", n, fibonacci(n));
return 0;
}
这个案例展示了C语言中的动态规划，用于计算斐波那契数列。通过计算斐波那契数列的值，我们可以了解动态规划的用法。
案例二十五：贪心算法
#include <stdio.h>
int maxProfit(int prices[], int n) {
int maxProfit = 0;
for (int i = 1; i < n; i++) {
if (prices[i] > prices[i - 1]) {
maxProfit += prices[i] - prices[i - 1];
}
}
return maxProfit;
}
int main() {
int prices[] = {7, 1, 5, 3, 6, 4};
int n = sizeof(prices) / sizeof(prices[0]);
printf("Maximum profit is: %d\n", maxProfit(prices, n));
return 0;
}
这个案例展示了C语言中的贪心算法，用于计算股票买卖的最大利润。通过计算最大利润，我们可以了解贪心算法的用法。
案例二十六：回溯算法
”`c
#include
void printBoard(char board[3][3]) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%c ", board[i][j]);
}
printf("\n");
}
}
int isSafe(char board[3][3], int row, int col, char player) {
if (board[row][col] == ' ') {
return 1;
}
for (int i = 0; i < 3; i++) {
if (board[row][i] == player || board[i][col] == player) {
return 0;
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (board[i][j] == player && i + j == row + col) {
return 0;
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {