C++ C+中的递归分解+；

我正在努力学习递归。分解练习绘制递归树有困难-在下面的代码中，基本情况包括函数窗口。drawPolarLine（branchbase，length，angle），它返回刚绘制的分支末端的GPoint（x和y）。任何递归解决方案都必须跟踪大量gpoint。我不知道这是应该发生在堆栈帧中，还是应该使用向量来存储它们。使用向量似乎是沿着迭代解决方案的道路前进

无论如何，到目前为止，这是我非常混乱的代码

/**
 * File: trees.cpp
 * ---------------
 * Draws a recursive tree as specified in the Assignment 3 handout.
 */

#include <string>    // for string
#include <iostream>  // for cout, endl
using namespace std;

#include "console.h" // required of all CS106 C++ programs
#include "gwindow.h" // for GWindow class and its setTitle, setColor, and drawPolarLine methods
#include "gtypes.h"  // for GPoint class
#include "random.h"  // for randomChance function

const static double kWindowWidth = 600;
const static double kWindowHeight = 600;
const static string kWindowTitle = "Recursive Trees";
const static double kTrunkLength  = kWindowHeight/4;
const static double kShrinkFactor = 0.70;
const static int kBranchAngleSeparation = 15;
const static int kTrunkStartAngle = 90;
const static string kLeafColor = "#2e8b57";
const static string kTrunkColor = "#8b7765";
const static double kBranchProbability = 1.0;

static GPoint drawTree(GWindow& window, int order, GPoint branchBase, double length, int angle, Vector<GPoint>& branches);

const static int kHighestOrder = 5;
int main() {
    GWindow window(kWindowWidth, kWindowHeight);
    window.setWindowTitle(kWindowTitle);
    cout << "Repeatedly click the mouse in the graphics window to draw " << endl;
    cout << "recursive trees of higher and higher order." << endl;
    GPoint trunkBase(window.getWidth()/2, window.getHeight());
    Vector<GPoint> branches;
    for (int order = 0; order <= kHighestOrder; order++) {
        waitForClick();
        window.clear();
        drawTree(window, order, trunkBase, kTrunkLength, kTrunkStartAngle, branches);
    }

    cout << endl;
    cout << "All trees through order " << kHighestOrder << " have been drawn." << endl;
    cout << "Click the mouse anywhere in the graphics window to quit." << endl;
    waitForClick();
    return 0;
}

static GPoint drawTree(GWindow& window, int order, GPoint branchbase, double length, int angle, Vector<GPoint>& branches) {
    if (order == 0) {

        GPoint base = window.drawPolarLine(branchbase, length, angle);
        branches.add(base);
        return branchbase;
    }

        window.setColor(order < 2 ? kLeafColor : kTrunkColor);

        branchbase = branches.get(order - 1);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle - 45, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle - 30, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle - 15, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle + 15, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle + 30, branches);
        drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle + 45, branches);


        return drawTree(window, order - 1, branchbase, length * kShrinkFactor, angle, branches);
    }
    // update this function to wrap around another version of drawTree, which
    // recursively draws the tree of the specified order....

/**
*文件：trees.cpp
* ---------------
*绘制作业3讲义中指定的递归树。
*/
#包含//用于字符串
#包括//for cout，endl
使用名称空间std；
包括“控制台H”/ /所有CS106 C++程序的要求
#为gwindow类及其setTitle、setColor和drawPolarLine方法包括“gwindow.h”//
#包括GPoint类的“gtypes.h”//
#包括“random.h”//用于随机机会函数
常数静态双kWindowWidth=600；
常数静态双kWindowHeight=600；
常量静态字符串kWindowTitle=“递归树”；
常数静态双K运行长度=千瓦时/4；
常数静态双K收缩系数=0.70；
常数静态int=15；
常量静态int kTrunkStartAngle=90；
常量静态字符串kLeafColor=“#2e8b57”；
常量静态字符串kTrunkColor=“#8b7765”；
常数静态双概率=1.0；
静态GPoint绘图树（GWindow和window、int顺序、GPoint分支、双长度、int角度、向量和分支）；
常数static int kHighestOrder=5；
int main（）{
GWindow窗（kWindowWidth，Kwindowwheight）；
window.setWindowTitle（kWindowTitle）；
cout这个问题需要一种与经典递归示例（如排序）稍有不同的方法，在经典递归示例中，问题集在每次递归时都会减少，并且有一个自然限制（问题大小=最大顺序）
{
返回；
}
/*抽枝*/
setColor（当前顺序-最大顺序<2？kLeafColor:kTrunkColor）；
GPoint end=window.drawPolarLine（分支基、长度、角度）；
/*从当前分支开始绘制高阶分支*/
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩因子，角度-45，分支）；
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩因子，角度-30，分支）；
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩因子，角度-15，分支）；
drawTreeOrder（窗口、顺序+1、最大顺序、结束、长度*k收缩因子、角度、分支）；
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩系数，角度+15，分支）；
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩系数，角度+30，分支）；
drawTreeOrder（窗口，顺序+1，最大顺序，结束，长度*k收缩因子，角度+45，分支）；
}
/*方便功能，因此调用者不必麻烦处理当前订单*/
void drawTree（GWindow&window，int max_顺序，GPoint branchbase，双倍长度，int角度）
{
绘图树顺序（窗口，0，最大顺序，分支基，长度，角度）；
}

很有趣。这会在第一次点击时抛出整棵树，然后在随后的每次点击中分阶段将其移除，从外部叶子到树干。但这非常接近于练习所需要的——即从树干开始，到树叶，分阶段绘制树木。

void drawTreeOrder(GWindow& window, int curr_order, int max_order, GPoint branchBase, double length, int angle)
{
    /* Check if there is more work to do */
    if (curr_order >= max_order)
    {
        return;
    }

    /* Draw a branch */
    window.setColor(curr_order - max_order < 2 ? kLeafColor : kTrunkColor);
    GPoint end = window.drawPolarLine(branchBase, length, angle);

    /* Draw the higher-order branches starting from the current one */
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle - 45, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle - 30, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle - 15, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle + 15, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle + 30, branches);
    drawTreeOrder(window, order + 1, max_order, end, length * kShrinkFactor, angle + 45, branches);
}

/* Convenience function, so the caller does not have to bother with curr_order */
void drawTree(GWindow& window, int max_order, GPoint branchbase, double length, int angle)
{
    drawTreeOrder(window, 0, max_order, branchBase, length, angle);
}