递归实现N个数的排列，八皇后

 

下面是几个递归程序，先来看看比较简单的一个递归程序，上20级楼梯，每次可以上1层或2层，问到达最顶曾有多少中走法。这个题是一个典型的递归问题，比较简单，具体代码如下：

public class Floor {

 

 

       private int floor_num = 0;

       private int sum = 0;

       public Floor(int n)

       {

              this.floor_num = n;

       }

      

       public void run(int n)

       {

              if(n >= this.floor_num)

              {

                     sum++;

              }

              else

              {    

                     run(n+1);      

                     run(n+2);

              }

       }

      

       public int getSun()

       {

              return this.sum;

       }

       public static void main(String[] args) {

              Floor floor = new Floor(4);

              floor.run(1);

              System.out.println("一共有" + floor.getSun() + "种走法");

       }

 

}

 

题2是一个输入N个数的排列组合问题，本题的算法不是很好，希望有待改进，思想就是用一个数组做选择器，从中选择器素到一个Result数组里，然后选择了后把源数组里的元素删除，Result里的元素也是同样的道理。这样就不会加入相同的元素。

代码如下

 

 

public class RankArray {

 

       private int array[] = null; //初始话的数组

       private int result[] = null; //输出结构数组

       private final int element; //初始话数组一个有多少个元素

       private int array_index = 0 ;

       private int result_index = -1;

       private int num = 0; //一共有多少总排列数

      

       public RankArray(int n)

       {

              this.element = n;

              this.array_index = n-1;

              array = new int[element];

              result = new int[element];

              for(int i=0;i<element;i++)

              {

                     array[i] = i+1;

              }

       }

      

       //删除已经进入RESULT里的array里的元素

       private void delete_array(int n)

       {

              for(int i=n;i<this.array_index;i++)

              {

                     this.array[i] = this.array[i+1];

              }

              this.array_index--;

       }

      

       //添加到result数组里

       private void add_result(int value)

       {

              this.result[++result_index] = value;

       }

      

       private void add_array(int n)

       {

             

              for(int i=this.array_index;i>n;i--)

                     this.array[i] = this.array[i-1];

                     this.array[n] = this.pop();

                     this.array_index++;

 

       }

       //返回result数组里最上层元素

       private int pop()

       {

              int temp = 0;

              if(result_index != -1)

                      temp = this.result[result_index];

              this.result_index--;

              return temp;

       }

      

       //计算

       public void reckon()

       {

             

              if(result_index == element-1)

              {

                     this.display();

              }

              else

              {

                     for(int i=0;i<=this.array_index;i++)

                     {

                           

                            this.add_result(this.array[i]);

                            this.delete_array(i);

                            this.reckon();

                            this.add_array(i);          

                     }

              }

       }

      

       //显示

       private void display()

       {

              System.out.print("第[" + (++num) +"]次 ");

              int i = 0;

              for(;i<element-1;i++)

              {

                     System.out.print(result[i]+" ,");

              }

              System.out.print(result[i] + "/n");

             

       }

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              RankArray run = new RankArray(5);

              run.reckon();

       }

 

}

结果如图

 

第3个是一个用C写的最简单的8皇后问题，这个算法也是最容易实现的算法

#include<stdio.h>

#define constant 8

char huang[constant][constant];

int panduan(int x,int y)/*判断X，Y8个方向是否有皇后*/

{

       int i,j;

       if(huang[x][y]!='X')

              return 0;

       for(i=x-1;i>=0;i--)/*判断X，Y左边是否有皇后*/

              if(huang[i][y]!='X')

                     return 0;

              for(i=x+1;i<constant;i++)/*判断X，Y右边是否有皇后*/

                     if(huang[i][y]!='X')

                            return 0;

                     for(j=y+1;j<constant;j++)/*判断X，Y下面是否有皇后*/

                            if(huang[x][j]!='X')

                                   return 0;

                            for(j=y-1;j>=0;j--)/*判断X，Y上面是否有皇后*/

                                   if(huang[x][j]!='X')

                                          return 0;

                                   i=x+1;j=y+1;/*判断X，Y右下是否有皇后*/

                                   while(i<constant&&j<constant)

                                          if(huang[i++][j++]!='X')

                                                 return 0;

                                          i=x-1;j=y-1;/*判断X，Y左上是否有皇后*/

                                          while(i>=0&&j>=0)

                                                 if(huang[i--][j--]!='X')

                                                        return 0;

                                                 i=x+1;j=y-1;/*判断X，Y右上是否有皇后*/

                                                 while(i<constant&&j>=0)

                                                        if(huang[i++][j--]!='X')

                                                        return 0;

                                                 i=x-1;j=y+1;/*判断X，Y左下是否有皇后*/

                                                 while(i>=0&&j<constant)

                                                        if(huang[i--][j++]!='X')

                                                               return 0;

                                                        return 1;/*上面都没返回表示X，Y8个方向内没的皇后*/

}

int wenti(int x,int y,int num)/*算法函数，用递归法*/

{ int i,j,px=0;

   if(num==constant)

        return 1;

   else {

          if(panduan(x,y))

          {

           huang[x][y]='Q';

              for(i=1;i<constant;i++)

                     for(j=0;j<constant;j++)

                     {     px=px+wenti(i,j,num+1);}

                     if(px>0) return 1;

                     else

                     { huang[x][y]='X';return 0;}

          }

   }

   return 0;

}

void main()

{

       int i,j,px=0;/*px来判断是否找到一个解决问题的算法。PX==1找到*/

       for(i=0;i<constant;i++)

              for(j=0;j<constant;j++)

                     huang[i][j]='X';

              for(i=0;i<constant;i++)/*设置第1排的皇后，讨论constant种情况，如果PX==1退出*/

              {px=wenti(0,i,0);if(px==1) break;}

              for(i=0;i<constant;i++)

              {

                     printf("%-2d |",i);

              for(j=0;j<constant;j++)

                     printf("-%c-|",huang[i][j]);

              printf("/n   |---|---|---|---|---|---|---|---|/n");

              }

}