整型数组处理算法（十二）请实现一个函数：最长顺子。[风林火山]

请实现一个函数：最长顺子；输入很多个整数(1<=数值<=13)，
返回其中可能组成的最长的一个顺子(顺子中数的个数代表顺的长度)； 其中数字1也可以代表14；
顺子包括单顺\双顺\3顺；
单顺的定义是连续5个及以上连续的数，比如1,2,3,4,5、3,4,5,6,7,8和10,11,12,13,1等；
双顺的定义是连续3个及以上连续的对(对:两个相同的数被称为对),
比如1,1,2,2,3,3、4,4,5,5,6,6,7,7和11,11,12,12,13,13,1,1等;
3顺的定义是连续2个及以上连续的3张(3张:3个相同的数被称为3张),
比如1,1,1,2,2,2、3,3,3,4,4,4,5,5,5,6,6,6和13,13,13,1,1,1等等;

比如：输入数组[1,5,2,3,4,4,5,9,6,7,2,3,3,4], 输出数组[2,2,3,3,4,4,5,5]

实现代码如下：

int putList(int k, map<int, map<int, int>* >& listData, map<int, int>* mapData)
{
int nFlag =0;
if (0 == k && mapData->size() >= 5)
{
nFlag =1;
//listData.put(mapData.size(), mapData);
listData.insert(pair <int, map<int, int>* >( mapData->size(), mapData));
}
if (1 == k && mapData->size() >= 3)
{
nFlag =1;
//listData.put(2 * mapData.size(), mapData);
listData.insert(pair <int,  map<int, int>* >(2* mapData->size(), mapData));
}
if (2 == k && mapData->size() >= 2)
{
nFlag =1 ;
//listData.put(3 * mapData.size(), mapData);
listData.insert(pair <int, map<int, int>* >( 3*mapData->size(), mapData));
}

return nFlag;
}

map<int, int>* getList(int* count, int k, int num, int& nMaxCount)
{
map<int, map<int, int>* > listData;//= new map<int, map<int, int>*>();
map<int, int>* mapTemp = NULL;

int flag = 0;

int nRet = 0;
for (int i = 1; i < num; i++)
{
if (count[i] > k && flag == 0)
{
flag = 1;
mapTemp = new map<int, int>;
//mapTemp.put(i, count[i]);
mapTemp->insert(pair <int, int>( i, count[i]));
}
else if (count[i] > k && flag == 1)
{
//mapTemp.put(i, count[i]);
mapTemp->insert(pair <int, int>( i, count[i]));
if (13 == i)
{
if (count[14 - i] > k)
{
//mapTemp.put(14 - i, count[14 - i]);
mapTemp->insert(pair <int, int>( 14 - i, count[14 - i]));
nRet = putList(k, listData, mapTemp);

//不是顺子，释放内存
if (nRet==0)
{
delete mapTemp;
mapTemp = NULL;
}

}
else
{
flag = 0;
nRet=putList(k, listData, mapTemp);
//不是顺子，释放内存
if (nRet==0)
{
delete mapTemp;
mapTemp = NULL;
}
}
}
}
else if (count[i] <= k && flag == 1)
{
flag = 0;
nRet=putList(k, listData, mapTemp);
//不是顺子，释放内存
if (nRet==0)
{
delete mapTemp;
mapTemp = NULL;
}
}
}

if (listData.size() > 0)
{
listData.rend();
map<int, map<int, int>* >::iterator it = listData.begin();

nMaxCount = (*it).first;

map<int, int>* mapReturn = (*it).second;
map<int, int>* maptemp;

it++;

for (; it!=listData.end(); it++)
{
maptemp = (*it).second;

delete maptemp;
maptemp = NULL;
}
return mapReturn;

//return listData[listData.size()-1];
//return list.get(list.lastKey());
}
else
return NULL;
}

int* GetLongeststr(int* array, int nCount, int& outCount, int MaxNum)
{
int* count = new int[MaxNum+1];
memset(count, 0, MaxNum*sizeof(int));

int nMaxLoop=0;
int nMaxTemp;
int nMax1Loop=0;
int nMax2Loop=0;
int nMax3Loop=0;
int nMaxkey =0;

for (int i = 0; i < nCount; i++)
{
if (array[i] < 1 || array[i] > MaxNum)
return NULL;
++count[array[i]];
}

map<int, map<int, int>*> allList;// = new TreeMap<Integer, Map<Integer, Integer>>();
map<int, int>* mapTemp = NULL;
map<int, int>* map1Temp = NULL;
map<int, int>* map2Temp = NULL;
map<int, int>* map3Temp = NULL;
for (int k = 0; k < 3; k++)
{
mapTemp = getList(count, k, MaxNum, nMaxTemp);
if (NULL != mapTemp)
{
if (0 == k)
{
//allList.put(map.size(), map);
//allList.insert(pair <int, map<int, int>*>( mapTemp->size(), mapTemp));
map1Temp = mapTemp;
nMax1Loop = nMaxTemp;
nMaxLoop=nMaxTemp;
}
else if (1 == k)
{
//allList.put(2 * map.size(), map);
//allList.insert(pair <int, map<int, int>*>( 2*mapTemp->size(), mapTemp));

if (nMaxTemp>=nMaxLoop)
{
map2Temp = mapTemp;
nMax2Loop = nMaxTemp;
nMaxLoop = nMaxTemp;
}
else
{
delete mapTemp;
mapTemp =NULL;
}
}
else
{
//allList.put(3 * map.size(), map);
//allList.insert(pair <int, map<int, int>*>( 3*mapTemp->size(), mapTemp));

if (nMaxTemp>=nMaxLoop)
{
map3Temp = mapTemp;
nMax3Loop = nMaxTemp;
nMaxLoop = nMaxTemp;
}
else
{
delete mapTemp;
mapTemp =NULL;
}
}
}
}

delete[] count;
count = NULL;

if (nMaxLoop>0)
{
if (nMaxLoop == nMax3Loop)
{
nMaxkey = 3;
mapTemp = map3Temp;
}
else if (nMaxLoop == nMax2Loop)
{
nMaxkey = 2;
mapTemp = map2Temp;
}
else
{
nMaxkey = 1;
mapTemp = map1Temp;
}

outCount = nMaxLoop;
int* result = new int[outCount];
int k;
int nAllCount = 0;

map<int, int>::iterator itorResult;
for (itorResult = mapTemp->begin(); itorResult!=mapTemp->end(); itorResult++)
{
k = itorResult->first;
for (int j =0; j<nMaxkey; j++)
{

result[nAllCount++] = k;

cout << itorResult->first <<",";
}
}
cout << endl;

if (map1Temp!=NULL)
{
delete map1Temp;
map1Temp = NULL;
}

if (map2Temp!=NULL)
{
delete map2Temp;
map2Temp = NULL;
}

if (map3Temp!=NULL)
{
delete map3Temp;
map3Temp = NULL;
}

return result;

}
else
{
outCount = 0;
return NULL;
}
}

有兴趣的朋友可以自己试试，仅提供参考。

转载请注明原创链接：/article/1385454.html