Sắp xếp cơ bản

void noi_bot(int *a, size_t n)
{
    for (size_t i = 0; i + 1 < n; ++i) {
        int da_doi = 0;

        /* Sau lượt i, i phần tử cuối đã đúng chỗ nên không cần xét nữa. */
        for (size_t j = 0; j + 1 < n - i; ++j)
            if (a[j] > a[j + 1]) {
                int t = a[j];

                a[j] = a[j + 1];
                a[j + 1] = t;
                da_doi = 1;
            }

        if (!da_doi)
            break;      /* không đổi lần nào nghĩa là đã sắp xong */
    }
}

void sap_xep_chon(int *a, size_t n)
{
    for (size_t i = 0; i + 1 < n; ++i) {
        size_t vt_nho = i;

        for (size_t j = i + 1; j < n; ++j)
            if (a[j] < a[vt_nho])
                vt_nho = j;

        if (vt_nho != i) {
            int t = a[i];

            a[i] = a[vt_nho];
            a[vt_nho] = t;
        }
    }
}

void sap_xep_chen(int *a, size_t n)
{
    for (size_t i = 1; i < n; ++i) {
        int    khoa = a[i];
        size_t j = i;

        /* Đẩy mọi phần tử lớn hơn khoa sang phải một ô. */
        while (j > 0 && a[j - 1] > khoa) {
            a[j] = a[j - 1];
            --j;
        }

        a[j] = khoa;
    }
}

typedef struct {
    char ten[16];
    int  lop;
} SinhVien;

SinhVien sv[4] = {
    { "An",  2 },
    { "Binh", 1 },
    { "Cuong", 2 },
    { "Dung", 1 },
};

/* Sắp theo lớp. Kết quả với thuật toán ổn định:
     Binh 1, Dung 1, An 2, Cuong 2      <- An vẫn trước Cuong

   Kết quả với thuật toán không ổn định có thể là:
     Dung 1, Binh 1, Cuong 2, An 2      <- thứ tự cũ bị đảo */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

static void sinh_ngau_nhien(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i) a[i] = rand();
}

static void sinh_da_sap(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i) a[i] = (int)i;
}

static void sinh_sap_nguoc(int *a, size_t n)
{
    for (size_t i = 0; i < n; ++i) a[i] = (int)(n - i);
}

static double do_thoi_gian(void (*sap)(int *, size_t),
                           const int *goc, size_t n)
{
    int *a = malloc(n * sizeof *a);

    if (a == NULL) return -1.0;

    memcpy(a, goc, n * sizeof *a);

    clock_t t0 = clock();

    sap(a, n);

    double giay = (double)(clock() - t0) / CLOCKS_PER_SEC;

    /* Dùng kết quả để trình biên dịch không xóa mất lời gọi khi bật -O2. */
    volatile int chan = a[n / 2];

    (void)chan;
    free(a);

    return giay;
}

#include <stdlib.h>

static int so_sanh_int(const void *x, const void *y)
{
    int a = *(const int *)x;
    int b = *(const int *)y;

    return (a > b) - (a < b);
}

int a[] = { 5, 1, 4, 2, 8 };
size_t n = sizeof a / sizeof a[0];

qsort(a, n, sizeof a[0], so_sanh_int);

typedef struct {
    char   ten[32];
    int    lop;
    double diem;
} SinhVien;

/* Sắp theo lớp tăng dần, cùng lớp thì theo điểm giảm dần,
   cùng điểm thì theo tên. */
static int so_sanh_sv(const void *x, const void *y)
{
    const SinhVien *a = x;
    const SinhVien *b = y;

    if (a->lop != b->lop)
        return (a->lop > b->lop) - (a->lop < b->lop);

    if (a->diem != b->diem)
        return (a->diem < b->diem) - (a->diem > b->diem);   /* giảm dần */

    return strcmp(a->ten, b->ten);
}

qsort(sv, n, sizeof sv[0], so_sanh_sv);