1. 打印“Hello, World!”
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
这是一个简单的C语言程序,用于打印出“Hello, World!”。
2. 变量声明和赋值
#include <stdio.h>
int main() {
int a = 5;
printf("The value of a is: %d\n", a);
return 0;
}
这里展示了如何声明和赋值一个整型变量a。
3. 运算符使用
#include <stdio.h>
int main() {
int x = 10, y = 5;
int sum = x + y;
int difference = x - y;
int product = x * y;
int quotient = x / y;
int remainder = x % y;
printf("Sum: %d\n", sum);
printf("Difference: %d\n", difference);
printf("Product: %d\n", product);
printf("Quotient: %d\n", quotient);
printf("Remainder: %d\n", remainder);
return 0;
}
在这个例子中,我们展示了基本的数学运算符的使用。
4. 控制语句 - if语句
#include <stdio.h>
int main() {
int num = 10;
if (num > 0) {
printf("The number is positive.\n");
}
return 0;
}
使用if语句检查一个数是否为正数。
5. 控制语句 - if-else语句
#include <stdio.h>
int main() {
int num = 10;
if (num > 0) {
printf("The number is positive.\n");
} else {
printf("The number is not positive.\n");
}
return 0;
}
if-else语句用于在条件不满足时执行另一个代码块。
6. 控制语句 - switch语句
#include <stdio.h>
int main() {
int day = 3;
switch(day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
case 4:
printf("Thursday\n");
break;
case 5:
printf("Friday\n");
break;
case 6:
printf("Saturday\n");
break;
case 7:
printf("Sunday\n");
break;
default:
printf("Invalid day\n");
}
return 0;
}
使用switch语句来根据不同的值执行不同的代码块。
7. 循环 - for循环
#include <stdio.h>
int main() {
for (int i = 1; i <= 5; i++) {
printf("The value of i is: %d\n", i);
}
return 0;
}
使用for循环来重复执行一段代码。
8. 循环 - while循环
#include <stdio.h>
int main() {
int i = 1;
while (i <= 5) {
printf("The value of i is: %d\n", i);
i++;
}
return 0;
}
使用while循环来重复执行一段代码。
9. 循环 - do-while循环
#include <stdio.h>
int main() {
int i = 1;
do {
printf("The value of i is: %d\n", i);
i++;
} while (i <= 5);
return 0;
}
使用do-while循环来至少执行一次代码块。
10. 数组声明和初始化
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
printf("The value of numbers[%d] is: %d\n", i, numbers[i]);
}
return 0;
}
这里展示了如何声明和初始化一个整型数组。
11. 字符串操作
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello";
char str2[50] = "World";
char str3[100];
strcpy(str3, str1);
strcat(str3, str2);
printf("Concatenated string: %s\n", str3);
printf("Length of str1: %ld\n", strlen(str1));
printf("Comparing str1 and str2: %d\n", strcmp(str1, str2));
return 0;
}
这里演示了如何操作字符串,包括复制、连接和比较。
12. 函数声明和定义
#include <stdio.h>
void sayHello() {
printf("Hello, World!\n");
}
int main() {
sayHello();
return 0;
}
这个例子展示了如何定义和调用一个函数。
13. 结构体
#include <stdio.h>
typedef struct {
char name[50];
int age;
float salary;
} Employee;
int main() {
Employee emp1;
strcpy(emp1.name, "John Doe");
emp1.age = 30;
emp1.salary = 50000.0;
printf("Name: %s\n", emp1.name);
printf("Age: %d\n", emp1.age);
printf("Salary: %.2f\n", emp1.salary);
return 0;
}
使用结构体来存储员工的信息。
14. 指针
#include <stdio.h>
int main() {
int num = 10;
int *ptr = #
printf("Value of num: %d\n", num);
printf("Address of num: %p\n", (void *)&num);
printf("Value of ptr: %d\n", *ptr);
printf("Address of ptr: %p\n", (void *)ptr);
return 0;
}
这里展示了指针的概念,包括如何声明、初始化和访问变量的地址。
15. 指针数组
#include <stdio.h>
#include <string.h>
int main() {
char *names[] = {"John", "Jane", "Doe"};
for (int i = 0; i < 3; i++) {
printf("Name %d: %s\n", i + 1, names[i]);
}
return 0;
}
这里展示了如何使用指针数组来存储和访问字符串。
16. 函数指针
#include <stdio.h>
void sayHello() {
printf("Hello, World!\n");
}
int main() {
void (*funcPtr)(void) = sayHello;
funcPtr();
return 0;
}
在这个例子中,我们使用函数指针来调用sayHello函数。
17. 动态内存分配
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL) {
*ptr = 10;
printf("Value of ptr: %d\n", *ptr);
free(ptr);
} else {
printf("Memory allocation failed.\n");
}
return 0;
}
这里展示了如何使用malloc和free来动态分配和释放内存。
18. 函数指针和回调函数
#include <stdio.h>
void sayHello() {
printf("Hello, World!\n");
}
void sayBye() {
printf("Bye, World!\n");
}
int main() {
void (*funcPtr)(void) = sayHello;
funcPtr();
funcPtr = sayBye;
funcPtr();
return 0;
}
在这个例子中,我们使用函数指针来调用不同的函数。
19. 链表
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *next;
} Node;
Node* createNode(int data) {
Node *newNode = (Node *)malloc(sizeof(Node));
if (newNode != NULL) {
newNode->data = data;
newNode->next = NULL;
}
return newNode;
}
void insertNode(Node **head, int data) {
Node *newNode = createNode(data);
if (*head == NULL) {
*head = newNode;
} else {
Node *current = *head;
while (current->next != NULL) {
current = current->next;
}
current->next = newNode;
}
}
void printList(Node *head) {
Node *current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
}
int main() {
Node *head = NULL;
insertNode(&head, 1);
insertNode(&head, 2);
insertNode(&head, 3);
printList(head);
return 0;
}
这个例子展示了如何使用链表来存储和访问数据。
20. 队列
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *items;
int front;
int rear;
int capacity;
} Queue;
Queue* createQueue(int capacity) {
Queue *queue = (Queue *)malloc(sizeof(Queue));
if (queue != NULL) {
queue->capacity = capacity;
queue->front = 0;
queue->rear = -1;
queue->items = (int *)malloc(sizeof(int) * capacity);
}
return queue;
}
int isEmpty(Queue *queue) {
return queue->front > queue->rear;
}
int isFull(Queue *queue) {
return queue->rear == queue->capacity - 1;
}
void enqueue(Queue *queue, int item) {
if (isFull(queue)) {
printf("Queue is full\n");
return;
}
queue->rear++;
queue->items[queue->rear] = item;
}
int dequeue(Queue *queue) {
if (isEmpty(queue)) {
printf("Queue is empty\n");
return -1;
}
int item = queue->items[queue->front];
queue->front++;
return item;
}
int main() {
Queue *queue = createQueue(5);
enqueue(queue, 1);
enqueue(queue, 2);
enqueue(queue, 3);
enqueue(queue, 4);
enqueue(queue, 5);
printf("Dequeued: %d\n", dequeue(queue));
printf("Dequeued: %d\n", dequeue(queue));
return 0;
}
这个例子展示了如何使用队列来存储和访问数据。
21. 栈
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int *items;
int top;
int capacity;
} Stack;
Stack* createStack(int capacity) {
Stack *stack = (Stack *)malloc(sizeof(Stack));
if (stack != NULL) {
stack->capacity = capacity;
stack->top = -1;
stack->items = (int *)malloc(sizeof(int) * capacity);
}
return stack;
}
int isEmpty(Stack *stack) {
return stack->top == -1;
}
int isFull(Stack *stack) {
return stack->top == stack->capacity - 1;
}
void push(Stack *stack, int item) {
if (isFull(stack)) {
printf("Stack is full\n");
return;
}
stack->items[++stack->top] = item;
}
int pop(Stack *stack) {
if (isEmpty(stack)) {
printf("Stack is empty\n");
return -1;
}
return stack->items[stack->top--];
}
int main() {
Stack *stack = createStack(5);
push(stack, 1);
push(stack, 2);
push(stack, 3);
push(stack, 4);
push(stack, 5);
printf("Popped: %d\n", pop(stack));
printf("Popped: %d\n", pop(stack));
return 0;
}
这个例子展示了如何使用栈来存储和访问数据。
22. 排序算法 - 冒泡排序
#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 arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
这个例子展示了冒泡排序算法,用于对数组进行排序。
23. 排序算法 - 选择排序
#include <stdio.h>
void selectionSort(int *arr, int n) {
for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
这个例子展示了选择排序算法,用于对数组进行排序。
24. 排序算法 - 插入排序
#include <stdio.h>
void insertionSort(int *arr, int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("Sorted array: \n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
这个例子展示了插入排序算法,用于对数组进行排序。
25. 排序算法 - 快速排序
#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 arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
printf("Sorted array: \n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
这个例子展示了快速排序算法,用于对数组进行排序。
26. 排序算法 - 归并排序
”`c
#include
void merge(int *arr, int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int *arr, int l, int r) {
if (l < r) {
int m = l + (r - l
