問題描述：

給定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、採用陣列每次開銷記憶體都蠻大的，可以使用連結串列進行存值，在排序，最後依次輸出。