递归打印星形图案 P>对于我的C++数据结构类，我们的任务是打印这样的恒星图案：P> < /P>

*
**
****
****
****
****
**
*

模式中的行数由用户输入确定。因此，如果用户输入4，将打印上面的模式

我们之前有一个作业，我们必须打印相反的图案，一个像这样的 ****
****
****
**
*
*
**
****
****
****
如果用户输入5，则会打印上面的图案。这个模式，上面的那个，我没有问题。我使用for循环打印上半部分，然后再次递归调用该函数，然后使用相同的for循环以相反的方向打印下半部分。以下是我用于上述模式的代码供参考：

int main()
{
    int number;                                             
    cout << "Enter the number of lines in the grid: ";      

    cin >> number;                                          
    printStars(number);                                     
    cout << endl << "Grid Pattern Complete - End of Program.";
    return 0;
} // end of main 

void printStars(int num)                        
{
    if (num < 0) cout << endl << "Please enter a non negative number." << endl;

        else{

            if (num == 0) return;               

            else{
            for (int q = 1; q <= num; q++)      
            {cout << "*";}
            cout << endl;

            printStars(num - 1);        

            for (int q = 1; q <= num; q++)      
            {cout << "*";} 

            cout << endl;
        } 
    } 
} // end printStars

intmain（）
{
整数；
数量；
印刷星号（编号）；
我建议使用两个递归函数，一个按递增顺序打印，另一个按递减顺序打印

在两个函数运行后，保存程序的副本

然后，您可以尝试创建一个函数，该函数同时执行星号的递增和递减顺序。
递归调用后，您不会打印星号：

void printStars(int num, int num2)
{
  if (num2 < num)
  {

      for (int e = num; e > num2; e--)
      {
          cout << "*";
      }

      cout << endl;

      printStars(num - 1, num2);

      for (int e = num; e > num2; e--)
      {
          cout << "*";
      }

        cout << endl;
  }
}

void printStars（int num，int num2）
{
如果（num2num2；e--）
{
cout如果你想递归地做这件事，你必须记住有多个状态：你计数到
N
的状态，以及你计数回到
1
的状态。因此，如果你必须递归地做，你需要跟踪那些额外的事情：

void printStarsImpl(int count, int initial, int sign)
                    ↑          ↑            ↑
                    current    termination  next step

这个函数只需要知道下一个调用哪个
printstarsiml（）

最初的呼叫是：

void printStars(int n) {
    printStarsImpl(1, n, +1);
}

尝试此操作。这是代码的最小修改版本。上限传递给所有递归，递归函数调用以1开头的值执行（第一行中只有1开始）：

如果使用声明为只有一个参数的函数，最简单的方法是在函数中使用静态局部变量

#include <iostream>

void print_stars( size_t n )
{
    static size_t m;

    if ( m++ != n )
    {
        for ( size_t i = 0; i < m; i++ ) std::cout << '*';
        std::cout << std::endl;
        print_stars( n );
    }

    --m;
    for ( size_t i = 0; i < m; i++ ) std::cout << '*';
    std::cout << std::endl;
}

int main() 
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        size_t n = 0;
        std::cin >> n;

        if ( !n ) break;

        std::cout << std::endl;
        print_stars( n );
        std::cout << std::endl;
    }

    return 0;
}

如果您不想在递归函数中使用静态变量，则可以使用标准流成员函数
width
来替代它

#include <iostream>
#include <iomanip>

void print_stars( size_t n )
{
    std::streamsize m = std::cout.width();

    if ( m++ != n )
    {
        std::cout.width( m );
        std::cout << std::setfill( '*' );
        std::cout << '*' << std::endl;
        std::cout.width( m );
        print_stars( n );
    }

    std::cout.width( m-- );
    std::cout << std::setfill( '*' );
    std::cout << '\n';
}

int main() 
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        size_t n = 0;
        std::cin >> n;

        if ( !n ) break;

        std::cout << std::endl;
        print_stars( n );
        std::cout << std::endl;
    }

    return 0;
}

#包括
#包括
无效打印星星（大小）
{
std:：streamsize m=std:：cout.width（）；
如果（m++！=n）
{
标准：计算宽度（m）；
std:：cout为了便于练习，使用递归函数打印星号，使用另一个函数确定星号的数量如何：

string ReturnStars(int number)
{
  if (number > 1)
    return "*" + ReturnStars(number -1);

  return "*";
}

void PrintStars(int start, int lines)
{
  cout << ReturnStars(start) << endl;

  if (start < lines)
    PrintStars(start + 1, lines);

  cout << ReturnStars(start) << endl;
}

int main()
{
  int numberLines = 1;
  cout << "Please enter a positive number to print a star pattern for: ";
  cin >> numberLines;
  PrintStars(1, numberLines);

  return 0;
}

字符串返回星（整数）
{
如果（数字>1）
返回“*”+返回星（数字-1）；
返回“*”；
}
无效打印星（整数开始，整数行）
{
我认为如果只使用一个递归函数，最好的答案应该是-

#include <iostream>

using namespace std;

void recursive(int current, int lastEnter, int limit, bool isLimitReached) {
    cout << "*";
    if(current == lastEnter ) {
        cout << endl;
        current = 0;
        if(isLimitReached == false) 
            lastEnter++;
        else lastEnter--;
    }
    if(current + 1 == limit) {
        isLimitReached = true;
    }
    current++;
    if(!(isLimitReached == true && lastEnter == 0))
        recursive(current, lastEnter, limit, isLimitReached);
}

int main()
{
    int num = 0;
    cout << "Enter max number of stars to be generated : ";
    cin >> num;
    recursive(1, 1, num, false);
    return 0;
}

使用递归是赋值的一部分吗？不使用递归似乎很容易做到这一点recursion@dwcanillas是的，赋值需要递归。这是正确处理它的唯一方法，只是指出打印模式的函数不应该假设任何关于参数值来源的信息。你应该能够使用这个有趣的方法操作与来自文件的参数、硬编码的参数等无缝连接。输入验证属于输入。@Darianidsani:我已经包含了一个答案，对您的代码做了一点修改。它按预期工作。它与您一样使用带额外参数的递归。我已经在ideone.com上对其进行了测试，并将链接和结果包含在我的答案。我不确定是否允许我用两个递归函数来实现它，因为他解释说，你只需要一个函数就可以实现。这很有效，我对它进行了一些调整，以符合要求，但效果非常好，谢谢
#include <iostream>

void print_stars( size_t n )
{
    static size_t m;

    if ( m++ != n )
    {
        for ( size_t i = 0; i < m; i++ ) std::cout << '*';
        std::cout << std::endl;
        print_stars( n );
    }

    --m;
    for ( size_t i = 0; i < m; i++ ) std::cout << '*';
    std::cout << std::endl;
}

int main() 
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        size_t n = 0;
        std::cin >> n;

        if ( !n ) break;

        std::cout << std::endl;
        print_stars( n );
        std::cout << std::endl;
    }

    return 0;
}

Enter a non-negative number (0-exit): 4

*
**
***
****
****
***
**
*


Enter a non-negative number (0-exit): 3

*
**
***
***
**
*


Enter a non-negative number (0-exit): 2

*
**
**
*


Enter a non-negative number (0-exit): 1

*
*


Enter a non-negative number (0-exit): 0

#include <iostream>
#include <iomanip>

void print_stars( size_t n )
{
    std::streamsize m = std::cout.width();

    if ( m++ != n )
    {
        std::cout.width( m );
        std::cout << std::setfill( '*' );
        std::cout << '*' << std::endl;
        std::cout.width( m );
        print_stars( n );
    }

    std::cout.width( m-- );
    std::cout << std::setfill( '*' );
    std::cout << '\n';
}

int main() 
{
    while ( true )
    {
        std::cout << "Enter a non-negative number (0-exit): ";

        size_t n = 0;
        std::cin >> n;

        if ( !n ) break;

        std::cout << std::endl;
        print_stars( n );
        std::cout << std::endl;
    }

    return 0;
}

string ReturnStars(int number)
{
  if (number > 1)
    return "*" + ReturnStars(number -1);

  return "*";
}

void PrintStars(int start, int lines)
{
  cout << ReturnStars(start) << endl;

  if (start < lines)
    PrintStars(start + 1, lines);

  cout << ReturnStars(start) << endl;
}

int main()
{
  int numberLines = 1;
  cout << "Please enter a positive number to print a star pattern for: ";
  cin >> numberLines;
  PrintStars(1, numberLines);

  return 0;
}

#include <iostream>

using namespace std;

void recursive(int current, int lastEnter, int limit, bool isLimitReached) {
    cout << "*";
    if(current == lastEnter ) {
        cout << endl;
        current = 0;
        if(isLimitReached == false) 
            lastEnter++;
        else lastEnter--;
    }
    if(current + 1 == limit) {
        isLimitReached = true;
    }
    current++;
    if(!(isLimitReached == true && lastEnter == 0))
        recursive(current, lastEnter, limit, isLimitReached);
}

int main()
{
    int num = 0;
    cout << "Enter max number of stars to be generated : ";
    cin >> num;
    recursive(1, 1, num, false);
    return 0;
}

Enter max number of stars to be generated : 6 
*  
**       
***    
****    
*****   
******  
*****     
****    
***    
**   
*