数据结构之算法——递归

        递归，其实就是函数调用其本身来实现某些算法。
        在非必要情况下，尽可能不用递归，而是使用迭代来进行处理。即，使用for、while、foreach等循环来取代递归。
        迭代使用的是循环结构，递归使用的是选择结构。
        每个递归定义必须至少有一个条件，当满足条件时递归不再进行。
        递归的优点：结构更清晰，代码更简洁，更容易让人理解，从而减少代码的阅读时间。
下面是两个经典的问题，一个经典的汉诺塔问题，是递归入门的基础，一个八皇后问题，一般是回溯算法的经典例题，在这里使用递归解决。

---

问题一：汉诺塔问题

        问题描述：在印度，有这么一个古老的传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片，一次只移动一片，不管在哪根针上，小片必在大片上面。当所有的金片都从梵天穿好的那根针上移到另外一概针上时，世界就将在一声霹雳中消灭，梵塔、庙宇和众生都将同归于尽。

        如上图所示，此时我们需要把A移动到C，需要写一个算法来解决这个问题。
        我们可以考虑，此时如果我们把A上面的63块金片移动到了B上，此时A上只有最下面的最大的那片金片，移动一次，把它移动到C上，然后这个时候，由于C上的金片最大，所以不管放哪片金片都没问题。
        第二步，把B上的62块金片移动到A上，B上只剩下C，这个时候又是只需要一次，就能移动成功，此时A上有62块金片，B上什么都没有，C上有已排列好的最大的两块金片。
        以此类推，移动n次后，就能移动完毕，把最初A上的64片金片全部移动到C上。

于是有
f(n + 1) = 2*f(n) + 1 -> [f(n + 1) + 1] = 2*[f(n) + 1]
f(1) = 1, -> f(n) + 1 = (1 + 1)^n -> f(n) = 2^n - 1。
f(64)= 2^64 - 1 = 18446744073709551615 　

        以下为汉诺塔的递归代码：

class Hanoi
{
    /// <summary>
    /// 移动汉诺塔盘子问题，得到移动的次数
    /// </summary>
    /// <param name="n">汉诺塔的层数</param>
    public void GetMoveCount(int n)
    {
        if (n <= 0)
            throw new Exception("层数出错！");

        int[] num = new int[n];
        for (int i = 1; i <= n; i++)
            num[i - 1] = i;

        Move(n, 'X', 'Y', 'Z');
    }

    private void Move(int n, char x, char y, char z)
    {
        if (1 == n)
        {
            Console.WriteLine("将第{0}个盘子从{1}轴移动到{2}轴上", n, x, z);
        }
        else
        {
            Move(n - 1, x, z, y);                                                       //将n-1个盘子从x轴移动到y轴上，把z轴作为辅助轴
            Console.WriteLine("将第{0}个盘子从{1}轴移动到{2}轴上", n, x, z);            //将x轴的最后一个盘子移动到z轴上
            Move(n - 1, y, x, z);                                                       //将剩余的n-1个盘子从y轴移动到z轴上，把x轴作为辅助轴
        }
    }
}

问题二：八皇后问题

        问题描述：在国际象棋中，皇后是最强大的一枚棋子，可以吃掉与其在同一行、列和斜线的敌方棋子。比中国象棋里的车强几百倍，比她那没用的老公更是强的飞起（国王只能前后左右斜线走一格）。
        八皇后问题是这样一个问题：将八个皇后摆在一张8*8的国际象棋棋盘上，使每个皇后都无法吃掉别的皇后，一共有多少种摆法？此问题在1848年由棋手马克斯·贝瑟尔提出，岂止是有年头，简直就是有年头，82年的拉菲分分钟被秒的渣都不剩。
        递归，再确定每一行的棋子位置之后往下一行进行放置，直到每一行棋子都放置完毕，然后输出这个棋盘上棋子的放置位置，然后返回到上一行的放置棋子位置，向后遍历，直到遍历完所有每行所有列可以摆放的位置为止。

        以下为参考代码：

class EightQueue
{
    private int count = 0;              //计数器，用于统计可放置的方法的数量

    public void Solution(int num)
    {
        int row = num, col = num;
        int[,] cheers = new int[row, col];

        //初始化棋盘，为0表示没有放置棋子，为1表示放置了皇后
        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                cheers[i, j] = 0;

        SolutionCore(0, col, cheers);

        Console.WriteLine("总共有{0}种方法放置八个皇后", count);
    }

    /// <summary>
    /// 遍历找出所有能够放置的方法
    /// </summary>
    /// <param name="startRow">起始的行数</param>
    /// <param name="cols">列数</param>
    /// <param name="cheers">棋盘</param>
    private void SolutionCore(int startRow, int cols, int[,] cheers)
    {
        //创建一个临时棋盘用于存放每一种放置的方法而不影响最初的棋盘
        int[,] tempCheers = new int[cols, cols];
        //初始化临时棋盘
        for (int i = 0; i < cols; i++)
            for (int j = 0; j < cols; j++)
                tempCheers[i, j] = cheers[i, j];

        //如果满足条件，打印棋子放置的位置
        if (startRow == 8)
        {
            //因为count从0开始的，所以输出数的时候需要+1
            Console.WriteLine("第{0}种放置的方法：", count + 1);
            for (int i = 0; i < cols; i++)
            {
                for (int j = 0; j < cols; j++)
                    Console.Write(cheers[i, j] + "  ");
                Console.WriteLine();
            }
            Console.WriteLine();

            count++;
        }
        else
        {
            //判断该列的哪个位置可以放置棋子
            for (int i = 0; i < cols; i++)
            {
                //如果可以放置棋子，那么进入下一行
                if (CanPut(startRow, i, tempCheers))
                {
                    for (int j = 0; j < cols; j++)
                        tempCheers[startRow, j] = 0;
                    tempCheers[startRow, i] = 1;
                    SolutionCore(startRow + 1, cols, tempCheers);
                }
            }
        }
    }

    /// <summary>
    /// 检查当前位置是否可以放置棋子
    /// </summary>
    /// <param name="startRow">当前行</param>
    /// <param name="col">当前列</param>
    /// <param name="cheers">棋盘</param>
    /// <returns></returns>
    private bool CanPut(int startRow, int col, int[,] cheers)
    {
        int length = cheers.GetLength(0);                 //获取棋盘的行列值，方便下面的计算
        //创建五个可能性的标志并初始化
        bool[] flag = new bool[5];
        for (int i = 0; i < flag.Length; i++)
        {
            flag[i] = false;
        }

        //判断该棋子的一列是否存在其他棋子
        for (int row = 0; row < length; row++)
        {
            if (1 == cheers[row, col])
            {
                flag[0] = true;
                break;
            }
        }


        //判断该棋子的左上方是否存在其他棋子
        for (int i = startRow - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
        {
            if (1 == cheers[i, j])
            {
                flag[1] = true;
                break;
            }
        }


        //判断该棋子的右下方是否存在其他棋子
        for (int i = startRow + 1, j = col + 1; i < length && j < length; i++, j++)
        {
            if (1 == cheers[i, j])
            {
                flag[2] = true;
                break;
            }
        }

        //判断该棋子的右上方是否存在其他棋子
        for (int i = startRow - 1, j = col + 1; i >= 0 && j < length; i--, j++)
        {
            if (1 == cheers[i, j])
            {
                flag[3] = true;
                break;
            }
        }

        //判断该棋子的左下方是否存在其他棋子
        for (int i = startRow + 1, j = col - 1; i < length && j >= 0; i++, j--)
        {
            if (1 == cheers[i, j])
            {
                flag[4] = true;
                break;
            }
        }

        //判断当前是否可以放置棋子，如果五个方向都没有其他棋子（flag全部为false），则可以放置
        for (int i = 0; i < flag.Length; i++)
        {
            if (flag[i])
                return false;
        }
        return true;
    }

}