算法题：字符串按照数字展开

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u014573686/article/details/89409710

题目

给定一个字符串，字符串包含数字，大小写字母与括号，（包括大括号，中括号和小括号）括号可以嵌套，即括号里边可以出现数字和括号，按照如下的跪着对字符串进行展开，不需要考虑括号不成对匹配的问题，用例保证括号匹配，同时保证每个数字后面都有括号，不用考虑数字后边没有括号的情况，即 2a2(b)这种情况不用考虑。

1）数字表示括号里的字符串重复的次数，展开后的字符串不包括括号。

2）字符串展开是逆序展开

输入描述：

  输入一个长度小于100的字符串

输出描述：

输出展开后的字符串

示例1：输入输出示例仅供调试，后台判断数据一般不包含示例

   输入    abc3(A)

   输出   AAAcba

---

思路：

使用递归的思路
递归的出口：子串不包含数字时，就返回子串
包含数字时： 进行递归
字符串的结果是：数字之前的加上重复子串再加上最后的字符串

使用结构体存储子串以及子串的重复次数以及子串开始的位置
子串开始的位置方便截取数字之前的子串

总之：递归中是三部分相加

代码：

#include"stdafx.h"
#include<iostream>
#include<vector>
#include<string>
using namespace std;
typedef struct ChildStr
{
       string str; // 重复串
       int repNum; // 重复次数
       int left; // 存储子串外侧数字的位置
};
// 判断是否包含数字
bool isContainNumber(string str)
{
       bool flag = false;
       int length = str.length();
       for (int i = 0; i < length; i++)
       {
              if (str[i] <= '9' && str[i] >= '0')
              {
                     flag = true;
              }
       }
       return flag;
}
// 判断字符是不是数字
bool isNumber(char ch)
{
       if (ch >= '0' && ch <= '9')
              return true;
       else
              return false;
}

// 返回第一级需要重复的字符串和重复次数
// 并返回每个子串第一级数字开始的地方
vector<ChildStr> filterStr(string str)
{
       vector<ChildStr> childVec;
       int flag = 0;
       string val = "";
       ChildStr childStr;
       string numStr = "";
       int left = 0;
       for (int i = 0; i < str.length(); i++)
       {
              // 左右括号
              if (str[i] == '{' || str[i] == '[' || str[i] == '(')
              {
                     flag++;
                     // 发现子串存储子串重复次数并且将次数字符串置空
                     if (flag == 1)
                     {
                           childStr.repNum = atoi(numStr.c_str());
                           numStr = "";
                           continue;
                     }
              }
              if (str[i] == '}' || str[i] == ']' || str[i] == ')')
              {
                     flag--;
              }
              // 括号前的数字，因为有可能是多位数
              if (isNumber(str[i]) && 0 == flag)
              {
                     numStr += str[i];
              }
              if (0 != flag)
              {
                     val += str[i];
              }
              else
              {
                     if ("" != val)
                     {
                           childStr.str = val;
                           childStr.left = left;
                           childVec.push_back(childStr);
                     }
                     val = "";
                     left = i;
              }
       }
       return childVec;
}
string repate(string str, int num)
{
       string result = "";
       for (int i = 0; i < num; i++)
       {
              result += str;
       }
       return result;
}
// 递归展开字符串
string expandStr(string str)
{
       // 递归出口
       if (!isContainNumber(str))
       {
              return str;
       }
       else
       {
              int lf = 0;
              string ss = "";
              string result = "";
              vector<ChildStr> childStr = filterStr(str);
              for (auto cs : childStr)
              {
                     ss = "";  // 存储子串外部的字符串 例如： a2(df) 子串df外的 a  
                     for (; lf < cs.left; lf++)
                     {
                           ss += str[lf];
                     }
                     result = result + ss + repate(expandStr(cs.str),cs.repNum);
                     lf = lf + cs.str.length() + 3;  //  置换到下一个开始的地方
              }
              // 拼接最右侧括号右侧的字符串
              if (lf < str.length())
              {
                     for (int i = lf; i < str.length(); i++)
                     {
                           result += str[i];
                     }
              }
              return result;
       }
}

int main()
{
       string val;
       cin >> val;
       if ("" == val)
       {
              return 0;
       }
       string result = val;
       if (isContainNumber(val))
       {
              result = expandStr(val);
       }
       
       // 逆序输出
       for (int i = result.length() - 1; i < result.length(); i--)
       {
          cout << result[i];
       }
       system("pause");
       return 0;
}