Tìm giá trị nhỏ nhất và lớn nhất

int lon_nhat(const int *a, size_t n)
{
    int m = a[0];               /* khởi tạo bằng phần tử đầu, không phải bằng 0 */

    for (size_t i = 1; i < n; ++i)      /* bắt đầu từ 1 vì đã lấy a[0] rồi */
        if (a[i] > m)
            m = a[i];

    return m;
}

int nho_nhat(const int *a, size_t n)
{
    int m = a[0];

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

    return m;
}

void tim_min_max(const int *a, size_t n, int *mn, int *mx)
{
    if (n == 0) return;         /* không có gì để tìm */

    *mn = *mx = a[0];

    for (size_t i = 1; i < n; ++i) {
        if (a[i] < *mn) *mn = a[i];
        if (a[i] > *mx) *mx = a[i];
    }
}

int nho, lon;

tim_min_max(a, n, &nho, &lon);

#include <limits.h>

int lon_nhat(const int *a, size_t n)
{
    int m = INT_MIN;            /* nhỏ hơn hoặc bằng mọi giá trị int */

    for (size_t i = 0; i < n; ++i)
        if (a[i] > m) m = a[i];

    return m;
}

/* Trả về chỉ số của phần tử lớn nhất. Trả về n nếu mảng rỗng. */
size_t vi_tri_lon_nhat(const int *a, size_t n)
{
    if (n == 0) return n;

    size_t vt = 0;

    for (size_t i = 1; i < n; ++i)
        if (a[i] > a[vt])
            vt = i;

    return vt;
}

size_t vt = vi_tri_lon_nhat(diem, n);

if (vt < n)
    printf("Cao nhat: %s duoc %d diem\n", ten[vt], diem[vt]);

typedef struct {
    int    min, max;
    size_t vt_min, vt_max;
    int    hop_le;      /* 0 nếu mảng rỗng */
} ThongKe;

ThongKe phan_tich(const int *a, size_t n)
{
    ThongKe t = { 0, 0, 0, 0, 0 };

    if (n == 0) return t;

    t.min = t.max = a[0];
    t.hop_le = 1;

    for (size_t i = 1; i < n; ++i) {
        if (a[i] < t.min) { t.min = a[i]; t.vt_min = i; }
        if (a[i] > t.max) { t.max = a[i]; t.vt_max = i; }
    }

    return t;
}

#include <assert.h>

/* Cách 1: mã lỗi */
int tim_max1(const int *a, size_t n, int *kq)
{
    if (n == 0) return -1;

    *kq = a[0];

    for (size_t i = 1; i < n; ++i)
        if (a[i] > *kq) *kq = a[i];

    return 0;
}

/* Cách 3: khẳng định. Chỉ hoạt động khi biên dịch không có NDEBUG. */
int tim_max3(const int *a, size_t n)
{
    assert(a != NULL && n > 0);

    int m = a[0];

    for (size_t i = 1; i < n; ++i)
        if (a[i] > m) m = a[i];

    return m;
}

/* Ý tưởng: xét từng cặp. So hai phần tử trong cặp với nhau trước,
   rồi chỉ so cái nhỏ hơn với min và cái lớn hơn với max.
   Ba phép so sánh cho hai phần tử, thay vì bốn. */
void tim_min_max_nhanh(const int *a, size_t n, int *mn, int *mx)
{
    if (n == 0) return;

    size_t i;

    if (n % 2 == 1) {
        *mn = *mx = a[0];
        i = 1;
    } else {
        if (a[0] < a[1]) { *mn = a[0]; *mx = a[1]; }
        else             { *mn = a[1]; *mx = a[0]; }

        i = 2;
    }

    while (i + 1 < n) {
        int nho, lon;

        if (a[i] < a[i + 1]) { nho = a[i];     lon = a[i + 1]; }
        else                 { nho = a[i + 1]; lon = a[i];     }

        if (nho < *mn) *mn = nho;
        if (lon > *mx) *mx = lon;

        i += 2;
    }
}