5.5]求含 n(n>1) 个元素的顺序表L中的最大元素。C语言

在C语言中，如果你有一个包含n个元素的顺序表（数组或链表），找到最大元素的一种常见方法是遍历整个列表，逐个比较元素。这里提供一个简单的线性查找算法：

#include <stdio.h>

// 假设顺序表存储在一个整型数组里
int findMax(int arr[], int n) {
    // 初始化最大值为数组的第一个元素
    int max = arr[0];

    // 遍历从第二个元素到最后一个元素
    for (int i = 1; i < n; i++) {
        // 如果当前元素大于已知的最大值，则更新最大值
        if (arr[i] > max) {
            max = arr[i];
        }
    }

    return max;
}

int main() {
    int L[] = {5, 10, 1, 8, 3}; // 举例顺序表
    int size = sizeof(L) / sizeof(L[0]); // 计算列表长度

    int maxElement = findMax(L, size);
    printf("顺序表L中的最大元素是: %d\n", maxElement);

    return 0;
}

在这个例子中，`findMax`函数会返回输入数组`L`中的最大值。如果你想在链表上实现类似的功能，就需要遍历链表节点并比较值。

相关问题

5. 药店的药品销售统计系统（排序） [问题描述] 设计一系统，实现医药公司定期对销售各药品的记录进行统计，可按药品的编号、单价、销售量或销售额做出排名。 [实现提示] 在本设计中，首先从数据文件中读出各药品的信息记录，存储在顺序表中。各药品的信息包括：药品编号、药名、药品单价、销出数量、销售额。药品编号共4位，采用字母和数字混合编号，如：A125，前一位为大写字母，后三位为数字，按药品编号进行排序时，可采用基数排序法。对各药品的单价、销售量或销售额进行排序时，可采用多种排序方法，如直接插入排序、冒泡排序、快速排序，直接选择排序等方法。在本设计中，对单价的排序采用冒泡排序法，对销售量的排序采用快速排序法，对销售额的排序采用堆排序法。 药品信息的元素类型定义： typedef struct node { char num[4]; /*药品编号*/ char name[10]; /*药品名称*/ float price; /*药品单价*/ int count; /*销售数量*/ float sale; /*本药品销售额*/ }DataType; 存储药品信息的顺序表的定义： typedef struct { DataType r[MaxSize]; int length; }SequenList; 用c语言写

以下是药店药品销售统计系统的排序部分的代码实现（包括基数排序、冒泡排序、快速排序和堆排序）：

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

#define MaxSize 1000

typedef struct node {
    char num[4];  /*药品编号*/
    char name[10]; /*药品名称*/
    float price;  /*药品单价*/
    int count;    /*销售数量*/
    float sale;  /*本药品销售额*/
} DataType;

typedef struct {
    DataType r[MaxSize];
    int length;
} SequenList;

/* 基数排序 */
int GetDigit(char *num, int d)
{
    return num[d - 1] - '0';
}

void RadixSort(SequenList *L)
{
    int i, j, k, q;
    int bucket[10], max = 0, d = 1;
    DataType temp[MaxSize];
    for (i = 0; i < L->length; i++) {
        if (strlen(L->r[i].num) > max) {
            max = strlen(L->r[i].num);
        }
    }

    for (i = 0; i < max; i++) {
        memcpy(temp, L->r, sizeof(DataType) * L->length);
        memset(bucket, 0, sizeof(bucket));
        for (j = 0; j < L->length; j++) {
            k = GetDigit(temp[j].num, d);
            bucket[k]++;
        }
        for (j = 1; j < 10; j++) {
            bucket[j] += bucket[j - 1];
        }
        for (j = L->length - 1; j >= 0; j--) {
            k = GetDigit(temp[j].num, d);
            L->r[--bucket[k]] = temp[j];
        }
        d++;
    }
}

/* 冒泡排序 */
void BubbleSort(SequenList *L)
{
    int i, j;
    DataType temp;
    for (i = 0; i < L->length - 1; i++) {
        for (j = 0; j < L->length - 1 - i; j++) {
            if (L->r[j].price > L->r[j + 1].price) {
                temp = L->r[j];
                L->r[j] = L->r[j + 1];
                L->r[j + 1] = temp;
            }
        }
    }
}

/* 快速排序 */
int Partition(SequenList *L, int low, int high)
{
    DataType pivotkey = L->r[low];
    while (low < high) {
        while (low < high && L->r[high].count <= pivotkey.count) {
            high--;
        }
        L->r[low] = L->r[high];
        while (low < high && L->r[low].count >= pivotkey.count) {
            low++;
        }
        L->r[high] = L->r[low];
    }
    L->r[low] = pivotkey;
    return low;
}

void QuickSort(SequenList *L, int low, int high)
{
    int pivotloc;
    if (low < high) {
        pivotloc = Partition(L, low, high);
        QuickSort(L, low, pivotloc - 1);
        QuickSort(L, pivotloc + 1, high);
    }
}

/* 堆排序 */
void HeapAdjust(SequenList *L, int s, int m)
{
    int i;
    DataType temp = L->r[s];
    for (i = 2 * s; i <= m; i *= 2) {
        if (i < m && L->r[i].sale < L->r[i + 1].sale) {
            i++;
        }
        if (temp.sale >= L->r[i].sale) {
            break;
        }
        L->r[s] = L->r[i];
        s = i;
    }
    L->r[s] = temp;
}

void HeapSort(SequenList *L)
{
    int i;
    DataType temp;
    for (i = L->length / 2; i > 0; i--) {
        HeapAdjust(L, i, L->length);
    }
    for (i = L->length; i > 1; i--) {
        temp = L->r[1];
        L->r[1] = L->r[i];
        L->r[i] = temp;
        HeapAdjust(L, 1, i - 1);
    }
}

int main()
{
    int i;
    SequenList L = {
        {{"A123", "Drug1", 5.5, 100, 550}, {"B234", "Drug2", 3.3, 200, 660}, {"C345", "Drug3", 2.5, 150, 375}},
        3
    };

    RadixSort(&L);
    printf("按编号排序：\n");
    for (i = 0; i < L.length; i++) {
        printf("%s %s %.2f %d %.2f\n", L.r[i].num, L.r[i].name, L.r[i].price, L.r[i].count, L.r[i].sale);
    }

    BubbleSort(&L);
    printf("按单价排序：\n");
    for (i = 0; i < L.length; i++) {
        printf("%s %s %.2f %d %.2f\n", L.r[i].num, L.r[i].name, L.r[i].price, L.r[i].count, L.r[i].sale);
    }

    QuickSort(&L, 0, L.length - 1);
    printf("按销售量排序：\n");
    for (i = 0; i < L.length; i++) {
        printf("%s %s %.2f %d %.2f\n", L.r[i].num, L.r[i].name, L.r[i].price, L.r[i].count, L.r[i].sale);
    }

    HeapSort(&L);
    printf("按销售额排序：\n");
    for (i = 0; i < L.length; i++) {
        printf("%s %s %.2f %d %.2f\n", L.r[i].num, L.r[i].name, L.r[i].price, L.r[i].count, L.r[i].sale);
    }

    return 0;
}