正文

C语言编程：30个实战案例解锁编程奥秘

/0 浏览量
0327

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 #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,
-- 展开阅读全文 --