1. 打印Hello World
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
这是一个简单的C语言程序,用于打印“Hello, World!”到控制台。
2. 计算两个数的和
#include <stdio.h>
int main() {
int num1, num2, sum;
printf("Enter two numbers: ");
scanf("%d %d", &num1, &num2);
sum = num1 + num2;
printf("Sum = %d\n", sum);
return 0;
}
这个程序从用户那里接收两个整数,然后计算并打印它们的和。
3. 循环结构打印星号图案
#include <stdio.h>
int main() {
int i, j, rows;
printf("Enter the number of rows: ");
scanf("%d", &rows);
for(i = 1; i <= rows; i++) {
for(j = 1; j <= i; j++) {
printf("* ");
}
printf("\n");
}
return 0;
}
这个程序根据用户输入的行数打印一个直角三角形图案。
4. 使用嵌套循环打印乘法表
#include <stdio.h>
int main() {
int i, j;
for(i = 1; i <= 10; i++) {
for(j = 1; j <= 10; j++) {
printf("%d*%d=%d ", i, j, i*j);
}
printf("\n");
}
return 0;
}
这个程序打印一个10x10的乘法表。
5. 使用指针交换两个变量的值
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 10, y = 20;
printf("Before swap: x = %d, y = %d\n", x, y);
swap(&x, &y);
printf("After swap: x = %d, y = %d\n", x, y);
return 0;
}
这个程序使用指针交换两个整数的值。
6. 使用结构体存储学生信息
#include <stdio.h>
struct Student {
char name[50];
int age;
float marks;
};
int main() {
struct Student s1, s2;
printf("Enter information for student 1:\n");
printf("Name: ");
scanf("%s", s1.name);
printf("Age: ");
scanf("%d", &s1.age);
printf("Marks: ");
scanf("%f", &s1.marks);
printf("Enter information for student 2:\n");
printf("Name: ");
scanf("%s", s2.name);
printf("Age: ");
scanf("%d", &s2.age);
printf("Marks: ");
scanf("%f", &s2.marks);
printf("Student 1: %s, %d, %.2f\n", s1.name, s1.age, s1.marks);
printf("Student 2: %s, %d, %.2f\n", s2.name, s2.age, s2.marks);
return 0;
}
这个程序使用结构体存储和打印两个学生的信息。
7. 使用文件I/O读取和写入数据
#include <stdio.h>
int main() {
FILE *file;
char filename[] = "example.txt";
char buffer[100];
// 打开文件进行写入
file = fopen(filename, "w");
if(file == NULL) {
printf("Error opening file!\n");
return 1;
}
fprintf(file, "Hello, World!\n");
fclose(file);
// 打开文件进行读取
file = fopen(filename, "r");
if(file == NULL) {
printf("Error opening file!\n");
return 1;
}
while(fscanf(file, "%s", buffer) != EOF) {
printf("%s\n", buffer);
}
fclose(file);
return 0;
}
这个程序创建一个文件,写入一些文本,然后读取并打印该文件的内容。
8. 使用动态内存分配创建数组
#include <stdio.h>
#include <stdlib.h>
int main() {
int *array, i, size;
printf("Enter the size of the array: ");
scanf("%d", &size);
array = (int *)malloc(size * sizeof(int));
if(array == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
printf("Enter %d elements:\n", size);
for(i = 0; i < size; i++) {
scanf("%d", &array[i]);
}
printf("Elements of the array:\n");
for(i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
free(array);
return 0;
}
这个程序使用动态内存分配创建一个整数数组,从用户那里接收元素,然后打印它们。
9. 使用函数计算阶乘
#include <stdio.h>
long long factorial(int n) {
if(n == 0) {
return 1;
}
return n * factorial(n - 1);
}
int main() {
int n;
printf("Enter a number: ");
scanf("%d", &n);
printf("Factorial of %d = %lld\n", n, factorial(n));
return 0;
}
这个程序使用递归函数计算一个整数的阶乘。
10. 使用结构体和指针处理学生成绩
#include <stdio.h>
struct Student {
char name[50];
int age;
float marks;
};
void printStudent(struct Student *s) {
printf("Name: %s, Age: %d, Marks: %.2f\n", s->name, s->age, s->marks);
}
int main() {
struct Student s1 = {"John", 20, 85.5};
struct Student s2 = {"Jane", 22, 92.0};
printStudent(&s1);
printStudent(&s2);
return 0;
}
这个程序使用结构体和指针来处理和打印学生的信息。
11. 使用指针和数组处理字符串
#include <stdio.h>
#include <string.h>
void reverseString(char *str) {
int length = strlen(str);
for(int i = 0; i < length / 2; i++) {
char temp = str[i];
str[i] = str[length - i - 1];
str[length - i - 1] = temp;
}
}
int main() {
char str[100];
printf("Enter a string: ");
scanf("%s", str);
printf("Original string: %s\n", str);
reverseString(str);
printf("Reversed string: %s\n", str);
return 0;
}
这个程序使用指针和数组反转一个字符串。
12. 使用循环和数组查找最大元素
#include <stdio.h>
int main() {
int array[] = {5, 2, 9, 1, 5, 6};
int size = sizeof(array) / sizeof(array[0]);
int max = array[0];
for(int i = 1; i < size; i++) {
if(array[i] > max) {
max = array[i];
}
}
printf("Maximum element in the array: %d\n", max);
return 0;
}
这个程序使用循环和数组查找并打印最大元素。
13. 使用递归函数计算斐波那契数列
#include <stdio.h>
long long fibonacci(int n) {
if(n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int n;
printf("Enter a number: ");
scanf("%d", &n);
printf("Fibonacci of %d = %lld\n", n, fibonacci(n));
return 0;
}
这个程序使用递归函数计算斐波那契数列的值。
14. 使用循环和数组实现冒泡排序
#include <stdio.h>
void bubbleSort(int array[], int size) {
for(int step = 0; step < size - 1; step++) {
for(int i = 0; i < size - step - 1; i++) {
if(array[i] > array[i + 1]) {
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
}
int main() {
int array[] = {64, 34, 25, 12, 22, 11, 90};
int size = sizeof(array) / sizeof(array[0]);
bubbleSort(array, size);
printf("Sorted array: \n");
for(int i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
return 0;
}
这个程序使用冒泡排序算法对数组进行排序。
15. 使用指针和函数交换两个字符串
#include <stdio.h>
#include <string.h>
void swapStrings(char *str1, char *str2) {
char temp[100];
strcpy(temp, str1);
strcpy(str1, str2);
strcpy(str2, temp);
}
int main() {
char str1[100], str2[100];
printf("Enter first string: ");
scanf("%s", str1);
printf("Enter second string: ");
scanf("%s", str2);
printf("Before swap: %s %s\n", str1, str2);
swapStrings(str1, str2);
printf("After swap: %s %s\n", str1, str2);
return 0;
}
这个程序使用指针和函数交换两个字符串。
16. 使用函数和数组实现选择排序
#include <stdio.h>
void selectionSort(int array[], int size) {
int i, j, min_idx;
for(i = 0; i < size - 1; i++) {
min_idx = i;
for(j = i + 1; j < size; j++) {
if(array[j] < array[min_idx]) {
min_idx = j;
}
}
int temp = array[min_idx];
array[min_idx] = array[i];
array[i] = temp;
}
}
int main() {
int array[] = {64, 34, 25, 12, 22, 11, 90};
int size = sizeof(array) / sizeof(array[0]);
selectionSort(array, size);
printf("Sorted array: \n");
for(int i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
return 0;
}
这个程序使用选择排序算法对数组进行排序。
17. 使用递归函数实现二分查找
#include <stdio.h>
int binarySearch(int array[], int size, int key) {
int low = 0, high = size - 1, mid;
while(low <= high) {
mid = low + (high - low) / 2;
if(array[mid] == key) {
return mid;
} else if(array[mid] < key) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
int main() {
int array[] = {2, 3, 4, 10, 40};
int size = sizeof(array) / sizeof(array[0]);
int key = 10;
int result = binarySearch(array, size, key);
if(result == -1) {
printf("Element is not present in array\n");
} else {
printf("Element is present at index %d\n", result);
}
return 0;
}
这个程序使用二分查找算法在有序数组中查找一个元素。
18. 使用函数和数组实现插入排序
#include <stdio.h>
void insertionSort(int array[], int size) {
int i, key, j;
for(i = 1; i < size; i++) {
key = array[i];
j = i - 1;
while(j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j = j - 1;
}
array[j + 1] = key;
}
}
int main() {
int array[] = {12, 11, 13, 5, 6};
int size = sizeof(array) / sizeof(array[0]);
insertionSort(array, size);
printf("Sorted array: \n");
for(int i = 0; i < size; i++) {
printf("%d ", array[i]);
}
printf("\n");
return 0;
}
这个程序使用插入排序算法对数组进行排序。
19. 使用函数和结构体实现栈
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
struct Stack {
int top;
int items[MAX_SIZE];
};
void initializeStack(struct Stack *s) {
s->top = -1;
}
int isFull(struct Stack *s) {
return s->top == MAX_SIZE - 1;
}
int isEmpty(struct Stack *s) {
return s->top == -1;
}
void push(struct Stack *s, int item) {
if(isFull(s)) {
printf("Stack is full\n");
return;
}
s->items[++s->top] = item;
}
int pop(struct Stack *s) {
if(isEmpty(s)) {
printf("Stack is empty\n");
return -1;
}
return s->items[s->top--];
}
int main() {
struct Stack s;
initializeStack(&s);
push(&s, 10);
push(&s, 20);
push(&s, 30);
printf("Popped element: %d\n", pop(&s));
printf("Popped element: %d\n", pop(&s));
return 0;
}
这个程序使用结构体和数组实现了一个栈。
20. 使用函数和结构体实现队列
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
struct Queue {
int front, rear;
int items[MAX_SIZE];
};
void initializeQueue(struct Queue *q) {
q->front = q->rear = -1;
}
int isFull(struct Queue *q) {
return (q->rear + 1) % MAX_SIZE == q->front;
}
int isEmpty(struct Queue *q) {
return q->front == -1;
}
void enqueue(struct Queue *q, int item) {
if(isFull(q)) {
printf("Queue is full\n");
return;
}
if(isEmpty(q)) {
q->front = 0;
}
q->rear = (q->rear + 1) % MAX_SIZE;
q->items[q->rear] = item;
}
int dequeue(struct Queue *q) {
if(isEmpty(q)) {
printf("Queue is empty\n");
return -1;
}
int item = q->items[q->front];
if(q->front == q->rear) {
q->front = q->rear = -1;
} else {
q->front = (q->front + 1) % MAX_SIZE;
}
return item;
}
int main() {
struct Queue q;
initializeQueue(&q);
enqueue(&q, 10);
enqueue(&q, 20);
enqueue(&q, 30);
printf("Dequeued element: %d\n", dequeue(&q));
printf("Dequeued element: %d\n", dequeue(&q));
return 0;
}
这个程序使用结构体和数组实现了一个队列。
21. 使用函数和结构体实现链表
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next;
};
void insertAtBeginning(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 *node) {
while(node != NULL) {
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
int main() {
struct Node *head = NULL;
insertAtBeginning(&head, 3);
insertAtBeginning(&head, 1);
insertAtBeginning(&head, 2);
printList(head);
return 0;
}
这个程序使用链表实现了一个简单的列表,并添加了元素。
22. 使用函数和结构体实现二叉树
”`c
#include
struct Node {
int data;
struct Node *left, *right;
};
struct Node *createNode(int data) {
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
void insert(struct Node **root, int data) {
if(*root == NULL) {
*root = createNode(data);
return;
}
if(data < (*root)->data) {
insert(&((*root)->left), data);
} else if(data > (*root)->data) {
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, 50);
insert(&root, 30);
insert(&root, 20);
insert(&root, 40);
insert(&root, 70);
insert(&root, 60);
insert(&root,
