返回目录

题目描述：查找众数及中位数

众数是指一组数据中出现次数量多的那个数，众数可以是多个。
中位数是指把一组数据从小到大排列，最中间的那个数，如果这组数据的个数是奇数，那最中间那个就是中位数，如果这组数据的个数为偶数，那就把中间的两个数之和除以2，所得的结果就是中位数。
查找整型数组中元素的众数并组成一个新的数组，求新数组的中位数。

输入描述

输入一个一维整型数组，数组大小取值范围 0<N<1000，数组中每个元素取值范围 0<E<1000

输出描述

输出众数组成的新数组的中位数

示例：

题目解析

题目要求找到整型数组中的众数，可以使用哈希表来统计每个数出现的次数，然后找到出现次数最多的数，即为众数。如果有多个众数，都放入一个新数组中。接着，对新数组进行排序，找到其中位数即可。

具体步骤如下：

1. 使用哈希表统计每个数出现的次数，找到出现次数最多的数，即为众数。如果有多个众数，都放入一个新数组中。
2. 对新数组进行排序，找到其中位数。

Python算法源码

# 处理输入
input_str = input()
numbers = list(map(int, input_str.split()))

# 统计数字出现次数及出现最大次数
count_map = {}
for number in numbers:
    count_map[number] = count_map.get(number, 0) + 1

max_count = max(count_map.values())

# 获取出现最大次数的数字并排序
max_count_numbers = [num for num, count in count_map.items() if count == max_count]
max_count_numbers.sort()

# 计算中位数
if len(max_count_numbers) % 2 != 0:
    index = (len(max_count_numbers) + 1) // 2 - 1
    print(max_count_numbers[index])
else:
    index1 = len(max_count_numbers) // 2 - 1
    index2 = len(max_count_numbers) // 2
    print((max_count_numbers[index1] + max_count_numbers[index2]) // 2)

C算法源码

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

#define MAX_NUMBERS 1000

int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int main() {
    // 处理输入
    char input[1000];
    fgets(input, sizeof(input), stdin);

    int numbers[MAX_NUMBERS];
    int count_map[MAX_NUMBERS] = {0}; // 假设数字最多出现100次
    int max_count = 0;

    char *token = strtok(input, " ");
    int index = 0;
    while (token != NULL) {
        int num = atoi(token);
        numbers[index++] = num;
        count_map[num]++;
        if (count_map[num] > max_count) {
            max_count = count_map[num];
        }
        token = strtok(NULL, " ");
    }

    // 获取出现最大次数的数字并排序
    int max_count_numbers[MAX_NUMBERS];
    int max_count_index = 0;
    for (int i = 0; i < MAX_NUMBERS; i++) {
        if (count_map[i] == max_count) {
            max_count_numbers[max_count_index++] = i;
        }
    }
    qsort(max_count_numbers, max_count_index, sizeof(int), compare);

    // 计算中位数
    int median;
    if (max_count_index % 2 != 0) {
        int index = (max_count_index + 1) / 2 - 1;
        median = max_count_numbers[index];
    } else {
        int index1 = max_count_index / 2 - 1;
        int index2 = max_count_index / 2;
        median = (max_count_numbers[index1] + max_count_numbers[index2]) / 2;
    }

    printf("%d\n", median);

    return 0;
}

Java算法源码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 处理输入
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] parts = input.split(" ");
        List<Integer> numbers = new ArrayList<>();
        for (String part : parts) {
            int num = Integer.parseInt(part);
            numbers.add(num);
        }

        // 统计数字出现次数及出现最大次数
        Map<Integer, Integer> countMap = new HashMap<>();
        for (int number : numbers) {
            countMap.put(number, countMap.getOrDefault(number, 0) + 1);
        }
        int maxCount = 0;
        for (int count : countMap.values()) {
            if (count >= maxCount) {
                maxCount = count;
            }
        }

        // 获取出现最大次数的数字并排序
        List<Integer> maxCountNumbers = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
            if (entry.getValue() == maxCount) {
                maxCountNumbers.add(entry.getKey());
            }
        }
        Collections.sort(maxCountNumbers);

        // 计算中位数
        if (maxCountNumbers.size() % 2 != 0) {
            int index = (maxCountNumbers.size() + 1) / 2 - 1;
            System.out.println(maxCountNumbers.get(index));
        } else {
            int index1 = maxCountNumbers.size() / 2 - 1;
            int index2 = maxCountNumbers.size() / 2;
            System.out.println((maxCountNumbers.get(index1) + maxCountNumbers.get(index2)) / 2);
        }
    }
}