C语言：10元素数组输入优化、冒泡排序循环及最值求解方案问询

Hey there! Let's break down your questions and fix up that code step by step—since you're coming from MATLAB/Octave, C's approach to arrays does feel a bit different at first, but we'll get you sorted.

1. Better ways to input your 10-element array #

First off: the for loop you're using to input elements is actually the standard, most flexible way to do this in C. Unlike MATLAB, which lets you read an entire array with a single input call, C doesn't have a built-in function for that.

That said, you can tweak the experience to make it smoother:

• Instead of prompting for each integer individually, you can give one upfront prompt like Enter 10 integers (separated by spaces or hits enter): —users can type all 10 at once, and scanf will handle parsing them correctly.
• Avoid hardcoding the array length if you can (though 10 is small here)—define a constant like #define ARRAY_SIZE 10 so you can change it later without hunting through loops.

2. Fixing your bubble sort logic #

Your current sorting code only runs one pass through the array, which means it only swaps adjacent elements once—definitely not enough to fully sort the array. Bubble sort needs two nested loops to work properly:

• The outer loop controls how many passes we make (for n elements, we need at most n-1 passes, since each pass moves the largest unsorted element to its correct position).
• The inner loop handles comparing and swapping adjacent elements in each pass, and we can shorten it by one each time (since the end of the array becomes sorted after every pass).

Here's the corrected bubble sort code using for loops:

#define ARRAY_SIZE 10
// ... after inputting the array ...
int temp;
for (int i = 0; i < ARRAY_SIZE - 1; i++) {
    // Inner loop: skip the last i elements (already sorted)
    for (int k = 0; k < ARRAY_SIZE - 1 - i; k++) {
        if (a[k] > a[k+1]) {
            temp = a[k];
            a[k] = a[k+1];
            a[k+1] = temp;
        }
    }
}

If you want to use a while loop (with an optimization to exit early if the array becomes sorted), try this:

#define ARRAY_SIZE 10
// ... after inputting the array ...
int temp;
int swapped;
int unsorted_length = ARRAY_SIZE;

do {
    swapped = 0; // Reset swap flag
    for (int k = 0; k < unsorted_length - 1; k++) {
        if (a[k] > a[k+1]) {
            temp = a[k];
            a[k] = a[k+1];
            a[k+1] = temp;
            swapped = 1; // Mark that a swap happened
        }
    }
    unsorted_length--; // Shorten the unsorted portion
} while (swapped); // Exit if no swaps occurred (array is sorted)

3. A way better approach: skip sorting entirely! #

You're right to suspect bubble sort is overkill here—sorting the entire array just to get the min and max is doing way more work than necessary. Instead, you can traverse the array once to track the smallest and largest values directly. This runs in O(n) time (linear) instead of bubble sort's O(n²) (quadratic), which makes a huge difference as arrays get longer.

Here's how to implement this:

#include <stdio.h>
#define ARRAY_SIZE 10

int main() {
    int a[ARRAY_SIZE];
    int min_val, max_val;
    int i;

    // Input the array
    printf("Enter 10 integers: ");
    for (i = 0; i < ARRAY_SIZE; i++) {
        scanf("%d", &a[i]);
    }

    // Initialize min and max to the first element
    min_val = a[0];
    max_val = a[0];

    // Traverse the rest of the array
    for (i = 1; i < ARRAY_SIZE; i++) {
        if (a[i] < min_val) {
            min_val = a[i];
        }
        if (a[i] > max_val) {
            max_val = a[i];
        }
    }

    // Output results
    printf("Smallest = %d\nLargest = %d\n", min_val, max_val);
    return 0;
}

This code is simpler, faster, and gets exactly what you need without unnecessary sorting.

内容的提问来源于stack exchange，提问作者rustybandit