冒泡排序vs qsort
memcpy vs strcpy

冒泡排序：
for(i=0; i < n;i++)
    for(j=i+1; j< n;j++)
            ....

<stblib.h>
C 库函数 void qsort(void *base, size_t n_items, size_t size, int (*compar)(const void *, const void*)) 对数组进行排序 

    //复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。
    //memcpy则是根据其第3个参数决定复制的长度。
char *strcpy(char* dest, const char *src) void *memcpy(void *destin, void *source, unsigned n);

#include <stdio.h>
#include <string.h>
#include <math.h>

//qsort 排序法
#if 0 
int cmp(const void* a, const void *b)
{
    return strcmp((const char *)a, (const char *)b);
}

int main(void)
{
    int i = 0;
    int size = 0;
    scanf("%d", &size);    
    
    char arr[size][101]; //动态初始化，数组大小
    while(EOF != scanf("%s", &arr[i++][0]))
    {
        
    }
    
    qsort(&arr[0], size, 101, cmp);

    for(i=0;i<size;i++)
    {
        printf("%s\n", &arr[i][0]);
    }

    return 0;
}
#endif

//冒泡排序法：
#include <stdio.h>
#include <string.h>

int main() {
    int n;
    scanf("%d", &n);

    char strings[n][101];
    for (int i = 0; i < n; i++) {
        scanf("%s", strings[i]);
    }

    //复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。
    //memcpy则是根据其第3个参数决定复制的长度。
    char temp[101] = {'\0'};
    for(int i = 0; i < n-1; i++) {
        for(int j = i+1; j < n; j++) {
            if (strcmp(strings[i], strings[j]) > 0) {
                memcpy(temp, strings[i], 101);            //可以用char *strcpy(char* dest, const char *src)
                memcpy(strings[i], strings[j], 101);      //void *memcpy(void *destin, void *source, unsigned n);
                memcpy(strings[j], temp, 101);
            }
        }
    }

    for (int i = 0; i < n; i++) {
        printf("%s\n", strings[i]);
    }

    return 0;
}