CCF——数字排序

问题描述：

给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。

输入格式

输入的第一行包含一个整数n，表示给定数字的个数。
第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。

输出格式

　　输出多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的。
　　

样例输入

12
5 2 3 3 1 3 4 2 5 2 3 5

样例输出

3 4
2 3
5 3
1 1
4 1

约束

　1 ≤ n ≤ 1000，给出的数都是不超过1000的非负整数。

解题思路：

这题一看，说难也不难，说容易也不容易，不就是统计重复数字的个数吗，从头开始遍历，找相等不就行了，不过要输出是哪个数出现了多少次，按照题目的输出要求（出现次数多的优先输出，次数相同的，将小的那个数优先输出）的确不太容易。

1、定义两个一维数组，一个用来存储值，一个用来存储该数出现的次数。输入完毕之后，先对存储值的那个数组进行从小到大的排序，再统计下值出现的次数，存入到另外一个数组里面，最后从统计次数里面的数组选出最大的值，再来一次遍历即可完成题目要求。

Code：

#include <iostream>
using namespace std;
#define MAX 1005
int a[MAX] = { 0 }, b[MAX] = { 0 }; //a用来存储值，b用来存次数
int main()
{
    int n;
    while (cin >> n)
    {
        int k = 0;
        for (int i=0;i<n;i++)
        {
            cin >> a[i];
            b[i] = 1;        //先进行初始化
        }
        //进行从小到大排序
        for (int i=0;i<n;i++)
        for (int j=i+1;j<n;j++)
        {
            if (a[i]>a[j])
                swap(a[i], a[j]);   //利用函数库中的swap函数，如果记不住，那可以采用以下代码
                /*if(a[i]>a[j])
                {
                    int t;
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }*/
        }
        //这步统计次数，是关键，统计错误，这题就GG了
        for (int i = 1; i < n; i++)
        {
            if (a[i] == a[i-1])
            {
                b[i] = b[i - 1] + 1;
                b[i - 1] = 0;
            }
        }
        //选取次数最大的那个
        for (int i=0;i<n;i++)
        {
            if (b[i]>k)
            {
                k = b[i];
            }
        }
        //遍历输出
        for (int i=k;i>=1;i--)
            for (int j=0;j<n;j++)
            {
                if (i==b[j])
                {
                    cout << a[j] << " " << i << endl;
                }
            }
    }
    return 0;
}

2、第一种方案思路方面还是比较清晰，那能否用一个一维数组呢，答案当然是可以的，
那怎么进行存数和统计次数呢，如果用一个一维数组的下标当做值，所存的数据表示该数的次数，只需将该数的次数最大的那个表示出来，然后逐个递减输出相应的下标值就行了。

Code：

#include <iostream>
using namespace std;
#define MAX 1005
int a[MAX] = { 0 };
int main()
{
    int n;
    while (cin >> n)
    {
        int k = 0;
        memset(a, 0, sizeof(a));
        for (int i = 0; i < n; i++)
        {
            int m;
            cin >> m;
            for (int j = 0; j < MAX; j++)
            {
                if (j == m)
                {
                    a[j]=a[j]+1;
                }
            }
        }
        //选择最大的数
         for (int i=0;i<MAX;i++)
         {
             if (a[i]>k)
             {
                 k = a[i];
             }
         }
         //进行选择性输出
         for (int i=k;i>=1;i--)
         {
             for (int j=0;j<MAX;j++)
             {
                 if (i==a[j])
                     cout << j << " " << i << endl;
             }
         }
    }
    return 0;
}

3、既然是一维数组，那我也可以采用结构体数组来进行，定义一个结构体数组，包含两个成员，一个代表值，一个代表该值所存在的次数，这也蛮符合题目要求的，统计相同的次数，然后排下序，再输出。如果用C++的容器会更好一点。
Code:

#include <iostream>
#include <string.h>
using namespace std;
#define MAX 1005
//如果采用C++所提供的容器会更好一点
typedef struct
{
    int value;
    int index;
}Node;
Node vector[MAX];
int main()
{
    int n;
    while (cin >> n)
    {
        int k = 0;
        memset(vector, 0, sizeof(vector));
        for (int i = 0; i < n; i++)
        {
            int m;
            cin >> m;
            for (int j = 0; j < MAX; j++)
            {
                if (j == m)
                {
                    vector[j].value = j;
                    vector[j].index++;
                }
            }
        }
        //sort
        for (int i = 0; i < MAX; i++)
        {
            if (vector[i].index == 0)
                continue;
            for (int j = i+1; j < MAX; j++)
            {
                if (vector[j].index == 0)
                    continue;
                if (vector[i].index < vector[j].index)
            {
                    int t = vector[i].index;
                    vector[i].index = vector[j].index;
                    vector[j].index = t;
                    t = vector[i].value;
                    vector[i].value = vector[j].value;
                    vector[j].value = t;
                    continue;
                }
                if (vector[i].index==vector[j].index)
                 if (vector[i].value>vector[j].value)
                     {
                         int t;
                         t = vector[i].value;
                         vector[i].value = vector[j].value;
                         vector[j].value = t;
                         continue;
                     }

            }
        }
        for (int i = 0; i < MAX; i++)
        {
            if (vector[i].index == 0)
                continue;
            cout << vector[i].value << " " << vector[i].index << endl;
        }

    }
    return 0;
}

4、采用数组每次开销内存都蛮大的，可以使用链表进行存值，在排序，最后依次输出。