编写递归 function 将给定字符串转换为它所代表的数字

Question

在这段代码中，我想通过使用recursive function将string转换为integer但它给出了 output 否定。

#include <iostream>

using namespace std;

int convert1(string s) {
    if (s.length() == 1) {
        int i = s[0] - '0';
        return i;
    }

    int so = convert1(s.substr(0, s.length() - 1));
    int num = s[s.length()] - '0';
    int ans = so * 10 + num;
    return (int)ans;
}

int main()
{
    string s;
    cin >> s;
    cout << convert1(s) << endl;
}

Answer 1

如果您每次调用convert1时都尝试打印s[s.length()] ，您会看到它正在打印0 。 然后你从中减去'0' ( 48 ) 的值。

假设我们尝试转换"12" 。

长度不是1，所以我们在"1"上调用convert1 。

那是长度为 1，所以我们返回1 。

因此，如果so是1 ，并且s[s.length()]是0 ，那么num是-48 ， so * 10 + num计算结果为1 * 10 - 48 ，即-38 。

对于两位数输入，您将始终看到第一位数字乘以 10，减去 48。对于三位数字，您将看到（第一位数字 * 十负 48）乘以 10 负 48。这种模式继续下去。 如果第一个数字足够大，则乘以 10 减去 48 会产生一个正数。 如果它足够大，正数会继续通过递归传播。 如果它们变得小于 48，那么一旦结果为负，它就会变得更大，因为负数越多，递归调用就越多。

---

与您做事的方式相反，您可以在convert1中使用累加器参数。

int convert1(string s, int acc=0) {
    if (s.length() == 1) {
        return acc * 10 + (s[0] - '0');
    }

    return convert1(s.substr(1, s.length() - 1), 
                    acc * 10 + (s[0] - '0'));
}

每次递归调用 function 时，我们通过将累加器乘以 10 并加上第一个数字的值来更新累加器，并通过获取字符串的“尾部”来更新字符串。

或者更好，但离你原来的更远一点，当字符串为空时，我们返回累加器。

int convert1(string s, int acc=0) {
    if (s.empty()) return acc;

    return convert1(s.substr(1, s.length() - 1), 
                    acc * 10 + (s[0] - '0'));
}

这种尾递归的好处是，这个 function（如果经过适当的编译器适当优化）可以在恒定堆栈空间中运行。 尽管在这种情况下它是学术性的，因为int类型会在堆栈溢出之前溢出。

Answer 2

正常的方式

int main()
{
    string s;
    cin >> s;
    cout << strtol(s.c_str(), nullptr, 10) << endl;
}

由于某种原因递归

int convert_string(const char* string, int length){
   if (length == 0) {
      return 0;
   }

   int output = string[0] - '0';
   output *= pow(10, length - 1);
   output += convert_string(&string[1], --length);
   return output;
}

int main()
{
    std::string s;
    std::cin >> s;
    std::cout << convert_string(s.c_str(), s.length()) << std::endl;
}

Answer 3

当您计算最后一位数字时

int num = s[s.length()] - '0';

您可以越界访问该字符串。 将其更改为

int num = s[s.length() - 1] - '0';

并且您的代码有效。 低效。

您在每次递归中创建一个新的 substring。 有两种改进方法：

1. 制作一个助手 function 来复制字符串，然后调用递归 function。 递归 function 采用std::string & s然后可以使用s.pop_back() 。 作为附带好处，助手 function 可以轻松处理以“-”开头的字符串。 无论如何，你应该有这个助手。

2. 将参数更改为std::string_view那么它只是对字符串的引用，substring 只会缩小该引用。 该字符串永远不会被复制。 这实际上是唯一的变化，只需将std::string更改为std::string_view并完成。

我认为std::string_view是通往 go 的方式，但需要 c++17。 将它与处理“-”的助手结合起来。

接下来是s[s.length() - 1] ，可以写成s.back() 。 安全一点打字，没有一个错误的风险。

那么您终止递归的条件过于复杂。 你可以写

if (s.empty()) return 0;

而是以额外的递归调用为代价。 另一方面，这允许解析“”。 不确定哪种方式更快，更简单的测试可能会平衡额外的递归调用。 我喜欢它，因为它不重复数字转换代码，而且打字少。

接下来，如果您使用的是std::string_view ，则可以将s.substr(0, s.length() - 1)表达式更改为使用s.remove_suffix(1); .

所有这些结合起来为您提供：

int convert1(std::string_view s) {
    if (s.empty()) return 0;

    int num = s.back() - '0';
    s.remove_suffix(1);
    int so = convert1(s)
    int ans = so * 10 + num;
    return ans;
}

---

还有一件事要考虑，但它是对算法的完全重写：

您的递归不是尾递归。 这会占用与字符串长度成比例的堆栈空间。 虽然对于解析“int”，这不应该是一个问题，但对于更大的问题将是一个问题。 或者如果有人只是输入一个非常大的数字“14654645656348756...65464”。

为了解决这个问题，你必须改变你的算法。 而不是在最后将它们从前面截取数字，就像你会迭代地这样做：

int iterative_convert(const std::string &s) {
    int acc = 0;
    for (const auto c : s) acc = acc * 10 + (c - '0');
    return acc;
}

为了使这个递归，你必须将中间结果作为累加器传递给递归。 所以它变成了这样：

int convert1(std::string_view s, int acc = 0) {
    if (s.empty()) return acc;
    acc = 10 * acc + (s.front() - '0');
    return convert1(s.substr(1), acc);
}

不确定您是如何提出从后到前算法的，但从前到后会产生更好的代码。

注意：不需要 c++17，或者如果您愿意，也可以使用std::string::const_iterator （需要将 s.cend() 作为额外参数传递）或旧的const char *p = s.c_str();