华为oj---字符统计***

输入一串字符，请对字符中的各个英文字符（大小写分开统计），数字，空格进行统计，并按照统计个数由多到少输出,如果统计的个数相同，则按照ASII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。

实现以下接口：
    输入一个字符串，对字符中的各个英文字符，数字，空格进行统计（可反复调用）
    按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出
    清空目前的统计结果，重新统计
调用者会保证：
1、输入的字符串以‘\0’结尾。

例1：
    输入字符串“aadddccddc11 2###”
    输出信息“dc1a 2”
例2：
    输入字符串“Aaaabb 12”
    输出信息“ab 12A” 
    再次输入“A11122”
    输出信息“12aAb ”

#include<stdlib.h>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
bool compare(const pair<char, int>& p1, const pair<char, int>& p2){
	if (p1.second!=p2.second){
		return p1.second < p2.second;
	}
	else{
	
		return p1.first < p2.first;
	}
	

}
int charcot(char* input,char* output){
	if (NULL== input){
		return -1;
	}
	map<char, int> char_n;
	
	while (*input){
		if (((*input >= '0') && (*input <= '9')) 
			|| ((*input >= 'a') && (*input <= 'z')) 
			|| ((*input >= 'A') && (*input <= 'Z')) || 
			(*input = ' ')){
			if (char_n.at(*input)){
				char_n.insert(make_pair(*input, char_n.at(*input) + 1));
			}
			else{
				char_n.insert(make_pair(*input, 1));
			}
		}

		input++;
	}
	vector<pair<char, int>> char_um(char_n.begin(),char_n.end());
	sort(char_um.begin(), char_um.end(), compare);
	for (int i = 0; i < char_um.size();i++){
		*output = char_um[i].first;
		output++;
	}
	*output = '\0';
	return 0;


}
int main(){

	return 0;
}

方法一：链表操作

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

/// 声明数据结构
typedef struct stRst{
     char c;
     int num;
     struct stRst* next;
}Rst;

/// 定义全局变量
static char* gstrInput;
static Rst* gRst;
static int gRstNum = 0;

int main()
{
    void InputString(char* pInput);
    int GetStaticString(char* *pInput);
    void Clear();
    int num;
    char pInput[100];
    char* pInput2[63];
    for(;;)
    {
        cout<<"1:输入字符串  2:统计结果  3:清空数据  其它:退出"<<endl;
        cin>>num;
        switch(num)
        {
            case 1:
                cin>>pInput;
                InputString(pInput);
                break;
            case 2:
                cout<<GetStaticString(pInput2)<<endl;
                if(GetStaticString(pInput2))
                    cout<<pInput2[0]<<endl;
                break;
            case 3:
                Clear();
                break;
            default:
                return 0;
                break;
        }
    }
    return 0;
}

/// 功能：输入待统计字符串供用户统计
/// 输入：char* pInput  待统计的字符串
/// 输出：无
/// 返回：无
void InputString(char* pInput)
{
    if(!pInput)
        return;
    if(!gstrInput)
    {
        free(gstrInput);
        gstrInput = NULL;
    }
    /// 保存最新输入字符串
    gstrInput = (char*)malloc(strlen(pInput)+1);
    memset(gstrInput, 0, strlen(pInput)+1);
    strcpy(gstrInput, pInput);
}

/// 功能：获取前面输入的字符串的统计信息
/// 输入：无
/// 输出：char* *pInput 获取统计结果，内存由函数自己申请，在函数外部释放，如果没有统计信息，返回NULL
/// 返回：int  如果成功返回1，失败返回0
int GetStaticString(char* *pInput)
{
    if(gstrInput == NULL || strlen(gstrInput) <= 0)
    {
        *pInput = NULL;
        return 0;
    }
    int nNodeNum = 0;
    /// 新输入字符串统计
    char* pTmp = gstrInput;
    while(*pTmp) /// 遍历新输入字符串
    {
        ///符合'a'-'z', 'A'-'Z', '0'-'9', 空格的字符进行处理
        if(('a' <= (*pTmp) && (*pTmp) <= 'z') || ('A' <= (*pTmp) && (*pTmp) <= 'Z') ||
           ('0' <= (*pTmp) && (*pTmp) <= '9') || (*pTmp) == ' ')
        {
            if(NULL == gRst) ///如果统计结果是空，新创建节点保存
            {
                gRst = (Rst*)malloc(sizeof(Rst));
                memset(gRst, 0, sizeof(Rst));
                gRst->c = *pTmp;
                gRst->num = 1;
                nNodeNum++;
            }
            else ///统计结果非空
            {
                Rst* pTmpSearch = gRst;
                Rst* pTmpPreNode = gRst;
                bool bFound = false;
                while (pTmpSearch) ///遍历统计结果链表，有相同值的节点进行数值累加
                {
                    if(*pTmp == pTmpSearch->c)
                    {
                        pTmpSearch->num++;
                        bFound = true;
                        break;
                    }
                    pTmpPreNode = pTmpSearch;
                    pTmpSearch = pTmpSearch->next;
                }
                if(!bFound) /// 链表没有相同值节点，创建新节点并加到链表末尾
                {
                    Rst* pTmpNew = (Rst*)malloc(sizeof(Rst));
                    memset(pTmpNew, 0, sizeof(Rst));
                    pTmpNew->c = *pTmp;
                    pTmpNew->num = 1;
                    pTmpPreNode->next = pTmpNew;
                    nNodeNum++;
                }
            }
        }
        pTmp++;
    }
    if(gRst) /// 统计结果有值
    {
        gRstNum += nNodeNum;
        *pInput = (char*)malloc(gRstNum+1); /// 对传出参数申请动态内存
        memset(*pInput, 0, gRstNum+1);
        Rst* pTmpSearch = gRst;
        char* pChTmp = *pInput;
        while(pTmpSearch) /// 对统计结果的链表进行冒泡排序，规则为：按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出
        {
            Rst* pCur = pTmpSearch;
            Rst* pNext = pTmpSearch->next;
            while(pNext)
            {
                if((pNext->num > pCur->num) || (pNext->num == pCur->num && pNext->c < pCur->c))
                    pCur = pNext;
                pNext = pNext->next;
            }
            if(pTmpSearch != pCur)
            {
                char cTmp = pTmpSearch->c;
                int nTmp = pTmpSearch->num;
                pTmpSearch->c = pCur->c;
                pTmpSearch->num = pCur->num;
                pCur->c = cTmp;
                pCur->num = nTmp;
            }
            pTmpSearch = pTmpSearch->next;
        }
        pTmpSearch = gRst;
        char* pchTmp = *pInput;
        while(pTmpSearch) /// 将排序后的数据写到传出参数的内存中
        {
            *pchTmp++ = pTmpSearch->c;
            pTmpSearch = pTmpSearch->next;
        }
    }
    return 1;
}

/// 功能：清空前面输入的字符串的统计信息
/// 输入：无
/// 输出：无
/// 返回：无

void Clear() ///将全局变量内存释放并重新初始化
{
    if(gstrInput)
    {
        free(gstrInput);
        gstrInput = NULL;
    }
    if(gRst)
    {
        Rst* pCurNode = gRst;
        while(pCurNode)
        {
            Rst* pNextNode = pCurNode->next;
            free(pCurNode);
            pCurNode = pNextNode;
        }
        gRst = NULL;
    }
    gRstNum = 0;
}