输入一组无序的整数，编写程序按照整数出现次数由多到少输出整数及其出现次数，若出现次数相同，则按照输入顺序输出。

好的，您的问题已经记录下来了。针对您的问题，可以使用Python来实现，具体代码如下：

from collections import Counter

def sort_by_frequency(nums):
    counter = Counter(nums)
    sorted_counter = sorted(counter.items(), key=lambda x: (-x[1], nums.index(x[0])))
    return sorted_counter

if __name__ == '__main__':
    nums = [1, 3, 2, 2, 3, 1, 1, 2, 2, 4]
    sorted_nums = sort_by_frequency(nums)
    for item in sorted_nums:
        print(item[0], item[1])

以上示例代码中，`sort_by_frequency` 函数接收一个整数列表 `nums` 作为输入参数，通过 `collections.Counter` 对列表中每个数字的出现次数进行统计，并将统计结果按照要求进行排序返回（统计结果以元组的形式保存在列表中，元组的第一个元素为数字，第二个元素为该数字的出现次数）。最后，我们循环遍历排序结果并输出即可。

相关问题

用c语言实现输入一组无序的整数，编写程序按照整数出现次数由多到少输出整数及其出现次数，若出现次数相同，则按照输入顺序输出。

好的，我已经明白你的要求。针对你的问题，我们可以使用一个哈希表来记录每个整数的出现次数，并用一个数组来保存输入的整数。接下来，我们可以根据哈希表中每个整数的出现次数从大到小进行排序，并按照输入顺序输出整数及其出现次数。

具体的实现细节如下：

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

#define MAXSIZE 100    // 数组的最大长度

/* 哈希表节点 */
typedef struct _hash_node {
    int key;
    int value;
    struct _hash_node* next;
} hash_node;

/* 哈希表 */
typedef struct _hash_map {
    hash_node** table;
    int size;
} hash_map;

/* 初始化哈希表 */
void init_hash_map(hash_map* hmap) {
    hmap->table = (hash_node**)malloc(sizeof(hash_node*) * MAXSIZE);
    memset(hmap->table, 0, sizeof(hash_node*) * MAXSIZE);
    hmap->size = 0;
}

/* 插入哈希表 */
void insert_hash_map(hash_map* hmap, int key) {
    int index = (key % MAXSIZE + MAXSIZE) % MAXSIZE;    // 计算哈希值
    hash_node* node = hmap->table[index];
    while (node != NULL && node->key != key) {    // 查找节点
        node = node->next;
    }
    if (node == NULL) {    // 未找到节点，插入新节点
        node = (hash_node*)malloc(sizeof(hash_node));
        node->key = key;
        node->value = 1;
        node->next = hmap->table[index];
        hmap->table[index] = node;
        hmap->size++;
    } else {    // 找到节点，将节点值加一
        node->value++;
    }
}

/* 按照出现次数从大到小排序 */
int cmp(const void* a, const void* b) {
    hash_node* nd1 = *((hash_node**)a);
    hash_node* nd2 = *((hash_node**)b);
    if (nd1->value != nd2->value) {
        return nd2->value - nd1->value;
    } else {
        return nd1->key - nd2->key;
    }
}

/* 输出结果 */
void print_result(hash_map* hmap, int* nums, int len) {
    hash_node** nodes = (hash_node**)malloc(sizeof(hash_node*) * hmap->size);
    int cnt = 0;
    for (int i = 0; i < MAXSIZE; i++) {
        hash_node* node = hmap->table[i];
        while (node != NULL) {
            nodes[cnt++] = node;
            node = node->next;
        }
    }
    qsort(nodes, hmap->size, sizeof(hash_node*), cmp);
    for (int i = 0; i < hmap->size; i++) {
        int key = nodes[i]->key;
        int value = nodes[i]->value;
        for (int j = 0; j < len; j++) {    // 查找输入顺序
            if (nums[j] == key) {
                printf("%d %d\n", key, value);
                break;
            }
        }
    }
    free(nodes);
}

/* 主函数 */
int main() {
    hash_map hmap;
    init_hash_map(&hmap);
    int nums[MAXSIZE];
    int len = 0;
    printf("请输入一组无序整数，以空格分隔：\n");
    char s[100];
    gets(s);
    char* p = strtok(s, " ");
    while (p != NULL) {    // 解析输入字符串
        int num = atoi(p);
        nums[len++] = num;
        insert_hash_map(&hmap, num);
        p = strtok(NULL, " ");
    }
    print_result(&hmap, nums, len);
    return 0;
}

这样就实现了按照整数出现次数排序输出的功能。希望能对你有所帮助。如果还有其他问题，请随时提出。

【问题描述】 输入一组无序的整数，编写程序按照整数出现次数由多到少输出整数及其出现次数，若出现次数相同，则按照输入顺序输出。 【输入形式】 先从标准输入读入整数的个数（大于等于1，小于等于100），然后在下一行输入这些整数，各整数之间以一个空格分隔。 【输出形式】 在标准输出上按照整数出现次数由多到少输出整数及其出现次数，每行显示一个整数及其出现次数，两者以一个空格分隔，出现次数后跟一个回车；若出现次数相同，则按照输入顺序输出。

我理解了你的问题，请看下面的代码，这是一个基于 Python 的解决方案：

n = int(input())
nums = list(map(int, input().split()))

count_dict = {}
for num in nums:
    count_dict[num] = count_dict.get(num, 0) + 1

sorted_nums = sorted(count_dict.items(), key=lambda x: (-x[1], nums.index(x[0])))

for num, count in sorted_nums:
    print(num, count)

解释一下上面的代码：

1. 首先从标准输入读入整数的个数 n 和这些整数 nums。
2. 创建一个空字典 count_dict，用于统计每个整数出现的次数。
3. 遍历 nums，将其作为字典的键，值为其出现次数；也可以用 collections.Counter(nums) 自动统计出现次数。
4. 对字典 count_dict 按照值（即出现次数）从大到小排序，相同的按照键（即输入顺序）从小到大排列。这里用了 sorted 函数和 lambda 表达式来实现排序。注意这里的 nums.index(x[0])，即按照输入顺序排序，如果不加此项，当有两个数出现次数相同时，将随机输出。
5. 遍历排序后的字典，输出每个键值对，即整数及其出现次数。