实例1:打印“Hello, World!”
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
这个实例是C语言编程的基石,它展示了如何使用printf函数在屏幕上输出文本。
实例2:变量与赋值
#include <stdio.h>
int main() {
int a = 10;
printf("变量a的值是:%d\n", a);
return 0;
}
在这个例子中,我们学习了如何声明和赋值变量。
实例3:数据类型
#include <stdio.h>
int main() {
int i = 10;
float f = 10.5;
char c = 'A';
printf("整数:%d\n", i);
printf("浮点数:%f\n", f);
printf("字符:%c\n", c);
return 0;
}
这里介绍了C语言中的不同数据类型,包括整数、浮点数和字符。
实例4:运算符
#include <stdio.h>
int main() {
int a = 5, b = 3;
printf("加法:%d\n", a + b);
printf("减法:%d\n", a - b);
printf("乘法:%d\n", a * b);
printf("除法:%d\n", a / b);
printf("余数:%d\n", a % b);
return 0;
}
这个实例展示了C语言中的基本运算符。
实例5:条件语句
#include <stdio.h>
int main() {
int age = 18;
if (age >= 18) {
printf("你已经成年了。\n");
} else {
printf("你还未成年。\n");
}
return 0;
}
条件语句用于根据条件执行不同的代码块。
实例6:循环语句
#include <stdio.h>
int main() {
int i;
for (i = 1; i <= 5; i++) {
printf("循环次数:%d\n", i);
}
return 0;
}
循环语句允许我们重复执行一段代码。
实例7:数组
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
printf("数组元素:%d\n", numbers[i]);
}
return 0;
}
数组是存储一系列相同类型数据的地方。
实例8:函数
#include <stdio.h>
void printMessage() {
printf("这是一个函数。\n");
}
int main() {
printMessage();
return 0;
}
函数是代码的模块化,可以提高代码的可重用性。
实例9:指针
#include <stdio.h>
int main() {
int a = 10;
int *ptr = &a;
printf("变量a的地址:%p\n", (void *)ptr);
printf("通过指针访问的值:%d\n", *ptr);
return 0;
}
指针是存储变量地址的变量。
实例10:结构体
#include <stdio.h>
struct Person {
char name[50];
int age;
};
int main() {
struct Person p1;
strcpy(p1.name, "张三");
p1.age = 25;
printf("姓名:%s\n", p1.name);
printf("年龄:%d\n", p1.age);
return 0;
}
结构体允许我们将不同类型的数据组合在一起。
实例11:位运算
#include <stdio.h>
int main() {
int a = 5; // 0101
int b = 3; // 0011
printf("按位与:%d\n", a & b); // 0001
printf("按位或:%d\n", a | b); // 0111
printf("按位异或:%d\n", a ^ b); // 0110
printf("按位取反:%d\n", ~a); // 1110
return 0;
}
位运算允许我们对整数的二进制位进行操作。
实例12:文件操作
#include <stdio.h>
int main() {
FILE *fp = fopen("example.txt", "w");
if (fp == NULL) {
printf("文件打开失败。\n");
return 1;
}
fprintf(fp, "这是一个示例文件。\n");
fclose(fp);
return 0;
}
文件操作允许我们读取和写入文件。
实例13:动态内存分配
#include <stdio.h>
#include <stdlib.h>
int main() {
int *numbers = (int *)malloc(5 * sizeof(int));
if (numbers == NULL) {
printf("内存分配失败。\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;
}
动态内存分配允许我们在运行时分配内存。
实例14:字符串操作
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello";
char str2[50] = "World";
char str3[50];
strcpy(str3, str1);
strcat(str3, str2);
printf("合并后的字符串:%s\n", str3);
return 0;
}
字符串操作允许我们处理字符串数据。
实例15:结构体数组
#include <stdio.h>
struct Person {
char name[50];
int age;
};
int main() {
struct Person people[2] = {
{"张三", 25},
{"李四", 30}
};
for (int i = 0; i < 2; i++) {
printf("姓名:%s,年龄:%d\n", people[i].name, people[i].age);
}
return 0;
}
结构体数组允许我们将多个结构体实例存储在数组中。
实例16:指针数组
#include <stdio.h>
int main() {
char *names[3] = {"张三", "李四", "王五"};
for (int i = 0; i < 3; i++) {
printf("姓名:%s\n", names[i]);
}
return 0;
}
指针数组允许我们将多个字符串指针存储在数组中。
实例17:函数指针
#include <stdio.h>
void printMessage() {
printf("这是一个函数。\n");
}
int main() {
void (*funcPtr)() = printMessage;
funcPtr();
return 0;
}
函数指针允许我们将函数作为参数传递。
实例18:递归函数
#include <stdio.h>
int factorial(int n) {
if (n <= 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main() {
int num = 5;
printf("阶乘:%d\n", factorial(num));
return 0;
}
递归函数允许函数调用自身。
实例19:排序算法
#include <stdio.h>
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]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
bubbleSort(numbers, n);
printf("排序后的数组:");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
排序算法允许我们对数据进行排序。
实例20:查找算法
#include <stdio.h>
int linearSearch(int arr[], int n, int x) {
for (int i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
return -1;
}
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
int x = 25;
int result = linearSearch(numbers, n, x);
if (result == -1) {
printf("元素未找到。\n");
} else {
printf("元素在索引:%d\n", result);
}
return 0;
}
查找算法允许我们在数组中查找特定元素。
实例21:队列
#include <stdio.h>
#define MAX_SIZE 5
int queue[MAX_SIZE];
int front = -1;
int rear = -1;
void enqueue(int value) {
if (rear == MAX_SIZE - 1) {
printf("队列已满。\n");
} else {
if (front == -1) {
front = 0;
}
rear++;
queue[rear] = value;
}
}
int dequeue() {
if (front == -1) {
printf("队列为空。\n");
return -1;
} else {
int value = queue[front];
if (front == rear) {
front = -1;
rear = -1;
} else {
front++;
}
return value;
}
}
int main() {
enqueue(10);
enqueue(20);
enqueue(30);
printf("队列元素:%d\n", dequeue());
printf("队列元素:%d\n", dequeue());
return 0;
}
队列是一种先进先出(FIFO)的数据结构。
实例22:栈
#include <stdio.h>
#define MAX_SIZE 5
int stack[MAX_SIZE];
int top = -1;
void push(int value) {
if (top == MAX_SIZE - 1) {
printf("栈已满。\n");
} else {
stack[++top] = value;
}
}
int pop() {
if (top == -1) {
printf("栈为空。\n");
return -1;
} else {
return stack[top--];
}
}
int main() {
push(10);
push(20);
push(30);
printf("栈元素:%d\n", pop());
printf("栈元素:%d\n", pop());
return 0;
}
栈是一种后进先出(LIFO)的数据结构。
实例23:链表
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void insertAtBeginning(struct Node **head, int value) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = *head;
*head = newNode;
}
void printList(struct Node *node) {
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
insertAtBeginning(&head, 30);
insertAtBeginning(&head, 20);
insertAtBeginning(&head, 10);
printList(head);
return 0;
}
链表是一种动态数据结构,允许我们在运行时插入和删除元素。
实例24:树
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *left;
struct Node *right;
};
struct Node *createNode(int value) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
void insert(struct Node **root, int value) {
if (*root == NULL) {
*root = createNode(value);
} else if (value < (*root)->data) {
insert(&((*root)->left), value);
} else {
insert(&((*root)->right), value);
}
}
void printInOrder(struct Node *root) {
if (root != NULL) {
printInOrder(root->left);
printf("%d ", root->data);
printInOrder(root->right);
}
}
int main() {
struct Node *root = NULL;
insert(&root, 50);
insert(&root, 30);
insert(&root, 20);
insert(&root, 40);
insert(&root, 70);
insert(&root, 60);
insert(&root, 80);
printInOrder(root);
return 0;
}
树是一种非线性数据结构,由节点组成,每个节点有零个或多个子节点。
实例25:图
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 5
struct Node {
int vertex;
struct Node *next;
};
struct Graph {
int numVertices;
struct Node *vertices[MAX_VERTICES];
};
void addEdge(struct Graph *graph, int src, int dest) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->vertex = dest;
newNode->next = graph->vertices[src];
graph->vertices[src] = newNode;
}
void printGraph(struct Graph *graph) {
for (int i = 0; i < graph->numVertices; i++) {
struct Node *node = graph->vertices[i];
printf("顶点 %d 的邻接顶点:", i);
while (node != NULL) {
printf("%d ", node->vertex);
node = node->next;
}
printf("\n");
}
}
int main() {
struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph));
graph->numVertices = MAX_VERTICES;
for (int i = 0; i < MAX_VERTICES; i++) {
graph->vertices[i] = NULL;
}
addEdge(graph, 0, 1);
addEdge(graph, 0, 4);
addEdge(graph, 1, 2);
addEdge(graph, 1, 3);
addEdge(graph, 1, 4);
addEdge(graph, 2, 3);
addEdge(graph, 3, 4);
printGraph(graph);
return 0;
}
图是一种非线性数据结构,由节点(顶点)和边组成。
实例26:动态规划
#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 = 10;
printf("斐波那契数列的第%d项:%d\n", n, fibonacci(n));
return 0;
}
动态规划是一种解决优化问题的方法,它通过将问题分解成更小的子问题来解决。
实例27:贪心算法
#include <stdio.h>
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++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
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 numbers[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(numbers) / sizeof(numbers[0]);
quickSort(numbers, 0, n - 1);
printf("排序后的数组:");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}
贪心算法是一种在每一步都做出当前最优选择的方法。
实例28:回溯算法
”`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;
}
return 0;
}
int checkWin(char board[3][3], char player) {
for (int i = 0; i < 3; i++) {
if (board[i][0] == player && board[i][1] == player && board[i][2] == player) {
return 1;
}
if (board[
