我在 C++ 中创建了一个函数来递归反转字符串，但是之后如何使功能打印一个 endl？

I've created a function in C++ to reverse a string recursively, but how can I make the funtion print a endl afterwards?

本文关键字：一个 之后 何使 打印 endl 功能 递归 创建 C++ 函数 我在      更新时间：2023-10-16

这是在C++ 最初的提示是创建一个反转字符串的递归函数。该函数有效，但我不确定在反转字符串后如何endl函数中输入，以便在控制台中看起来不错。这有效：

string reverse(string str) {
if (str.size() == 1) {
return str;
}
string str2 = reverse(str.substr(1));
return str2 + str[0];
}

这样做怎么样：

string str="Hello";
cout << reverse(str) << endl;

在这里，您将反转字符串，打印它，然后开始一个新行。

您可以使用最后一个字符索引在里面放置换行符，如下所示：

string reverse(string str, int length) {
if (str.size() == 1) {
return str;
}
string str2 = reverse(str.substr(1), length);
// if are at the last character, we just insert a newline after it
if(length == str2.length())
{
return str2 + str[0] + 'n';
}
return str2 + str[0];
}

int main()
{
string str = "Hello";
// we get position of last character
cout << reverse(str, str.length() -1);
return 0;
}

在将字符串参数传递给reverse()函数之前，您可以在字符串参数前面附加换行符，

string str {"Hello"};
str = "n" + str;
cout << reverse(str);

如果要在reverse函数定义中执行此操作，则需要跟踪递归的深度，以便可以在递归的第一级中附加换行符，

string reverse(string str, int depth = 0) {
if(depth==0) {
str = "n" + str;
}
depth++;
if(str.size() == 1) {
return str;
}
string str2 = reverse(str.substr(1), depth);
return str2 + str[0];
}

如何在函数反转字符串后获取 endl in 在控制台中看起来不错。

供您考虑，reverse2(((下面，最后一个函数(具有

a) half the recursions
b) appends an eoln char
<小时 />
#include <algorithm>
using std::swap;
#include <iostream>
using std::cout, std::endl, std::flush;
#include <string>
using std::string, std::to_string;

// forward declarations
string reverse (string str); // from this post, with fix
//
string reverse2 (string str);

void test1(string s)
{
cout << "n  s1: " << s
<< "n  r1: " << reverse(s);
cout <<   "  -----" << endl;     // highlight lack of eoln
}
void test2(string s)
{
cout << "n  s2: " << s
<< "n  r2: " << reverse2(s);
cout <<   "  -----";              // highlight eoln appended!
}

int main(int , char** )
{
int retVal = 0;
test1("123456789");
test1("12345678");
test1("123");
test1("45");
test1("6");
test1("");  // empty string 
test2("987654321");
test2("87654321");
test2("321");
test2("54");
test2("6");
test2("");  // empty string
return retVal;
}

// implementation from OP's post (with fix for empty string)
string reverse (string str)
{
//if (str.size() == 1) { // fails test case (0 == str.size())
if (str.size() < 2)  { // fix
return str;
}
string str2 = reverse(str.substr(1));
return str2 + str[0];
}

// recursive alternative to consider
//                            left    right indx
void reverseR (string& s, int l,  int r)
{  //                 |
//            swaps s elements in-place
if ((r - l) >= 0)          // recursion termination clause
{
swap(s[static_cast<uint>(l)],
s[static_cast<uint>(r)]);  // modify s in place
reverseR (s, l+1, r-1);         // recursively call
}
}
// append eoln
string reverse2 (string str) // stack copy, modified-in-place-here
{  // index:      v--left         right--vvvvvvvvvvvvvv
reverseR (str, 0,    (static_cast<int>(str.size()-1))); // recursive swaps
return (str + 'n');     // return result + eoln
}

输出：

s1: 123456789
r1: 987654321  -----
s1: 12345678
r1: 87654321  -----
s1: 123
r1: 321  -----
s1: 45
r1: 54  -----
s1: 6
r1: 6  -----
s1: 
r1:   -----
s2: 987654321
r2: 123456789
-----
s2: 87654321
r2: 12345678
-----
s2: 321
r2: 123
-----
s2: 54
r2: 45
-----
s2: 6
r2: 6
-----
s2: 
r2: 
-----
<小时 />

更新 - 2020/06/08

仅供参考 - 我简要捕获了一些性能测量。

我在我 8 岁(而且速度很慢(的戴尔上用 Lubuntu 20.04 和 g++ v9.3.0 测量了这些。

  • 您的代码(反向((( 可在 2999 毫秒内处理 461,175 个 50 元素字符串

  • 与我的代码非常相似的东西(reverse2((( 可在 3000 毫秒内处理 13,783,340 个 50 个元素字符串

  • 和 std：：reverse，包装在一个符合函数中(但不是递归的( 可在 2999 毫秒内处理 15,917,504 50 个元素字符串

恕我直言，reverse(( 和 reverse2(( 之间的主要区别在于递归期间传递字符串的次数。

我对 std：：reverse(( 了解不多，但它的性能给我留下了深刻的印象。

相关文章：