递归.像蜗牛一样一步一步往上爬

递归这个点我写了很久，三天都在写递归的图形，写的真的有点心烦，第三天还没与写出来的时候，我坐在咖啡厅的角落里鄙视了一下自己的时候那颗玻璃心碎了一地，差点就要落下热泪。那天晚上，在公交车上，平时话多的我没有说话，我的小伙伴在旁边小心翼翼的安慰着我，但是那种“这个世界充满着满满的恶意”的感觉并没有消失。我们就那样安静地回到了寝室，我们告别的时候，何思对我说了一句很暖的话：“你别急，我会等你。好好休息，用好的状态去面对。”我是感动了.......(此处省略78个字)。

写递归的时候，我一直觉得我的思路很正确，我写的代码所表达的含义也很清楚明了了，但是运行的结果总是出乎意料的残酷。所以把思路细化是很关键的，同时一步步查错更是重中之重！例如在写三角递归的时候，思路就是：

1.在点击的时候先画一个三角形或矩形；

public void mouseClicked(MouseEvent e) {
        g.drawRect(s, z, w, h);
        A(s, z, w, h,j);
        if (i < 3) {
            x = e.getX();
            y = e.getY();
            g.drawLine(x, y, x, y);
            if (i == 0) {
                x = x1;
                y = y1;
            } else if (i == 1) {
                x = x2;
                y = y2;
            } else if (i == 2) {
                x = x3;
                y = y3;
            }
            i++;
        }
        g.drawLine(x1, y1, x2, y2);
        g.drawLine(x1, y1, x3, y3);
        g.drawLine(x2, y2, x3, y3);
        //j=0;
        F(x1, y1, x2, y2, x3, y3,j);// 直接放这里，不要放到主函数中去
    }

2.取三条边的中点，再调用画三角形的方法，注意坐标的变动；

public void F(int x1, int y1, int x2, int y2, int x3, int y3,int j) {
        int ex1, ex2, ex3;
    int ey1, ey3, ey2;
        j++;
        g.setColor(Color.green);
        ex1 = (x1 + x2) / 2;
        ey1 = (y1 + y2) / 2;
        ex2 = (x1 + x3) / 2;
        ey2 = (y1 + y3) / 2;
        ex3 = (x2 + x3) / 2;
        ey3 = (y2 + y3) / 2;
        g.drawLine(ex1, ey1, ex2, ey2);
        g.drawLine(ex1, ey1, ex3, ey3);
        g.drawLine(ex2, ey2, ex3, ey3);
        x2 = ex1;
        y2 = ey1;
        x3 = ex2;
        y3 = ey2;
        if(j>6) return;
        F(x1,y1, x2, y2, x3,y3,j);
         x2=x3*2-x1;
         y2=y3*2-y1;
         x1=ex3;
         y1=ey3;
         F(x1,y1,x2,y2,x3, y3,j);
         x3=x1*2-x2;
         y3=y1*2-y2;
         x2=ex1;
         y2=ey1;
        F(x1,y1, x2,y2,x3, y3,j);
        System.out.println("   " + ex1 + "  " + ey1 + "  " + ex2 + "  " + ey2
                + "  " + ex3 + "  " + ey3);
    }

写三角递归的难点就是：坐标的变动

相比较于三角的递归，矩形的递归就简单多了，因为它坐标的变动要简单一些：

public void A(int s, int z, int w, int h, int j) {
        //int ex1 , ey1;
        g.setColor(Color.blue);
        g.drawRect(s, z, w, h);
        s = s-w;
        z = z-h;
        w = w / 3;
        h = h / 3;
        g.drawRect(s, z, w, h);
        if (j > 5)return;
        A(s, z, w, h, j+1);
        s = s+4*w;
        A(s, z, w, h, j+1);
        s = s+4*w;
        A(s, z, w, h, j+1);
        z = z+4*h;
        A(s, z, w, h, j+1);
        z = z+4*h;
        A(s, z, w, h,j+1);
        s = s-4*w;
        A(s, z, w, h,j+1);
        s = s-4*w;
        A(s, z, w, h,j+1);
        z = z-4*h;
        A(s, z, w, h, j+1);
    }

运行的结果：

注意：

递归如果没有结束条件，则表示递归必须要不停的去开辟内存空间，来存储下一个要运行的方法，这样一致执行下去，内存肯定会不够使用，就会抛出堆栈内存溢出错误。
 所以必须要给递归添加一个退出的条件。
 
 什么情况下要使用递归呢？
  重复相同的工作，但是又不确定具体要重复执行的次数，就可以使用递归。