tsp递归程序实现(Java)（zz）

tsp递归程序实现(Java)（zz）

tsp递归程序实现(Java)（zz）

程序设计中，如果一个程序直接调用自己或通过一系列的过程间接调用自己，那么这个程序就称为递归程序，递归程序（直接或间接）调用自己的过程称为递归调用，其中直接调用自己的成为直接递归调用，间接调用自己的称为间接递归调用。直接递归调用形如：      
    funa（）
    {     ．．．
       funa（）；

       ．．．

}     

间接递归调用形如：

funa（）

{     ．．．

      funb（）；

      ．．．

}     

funb（）

{  ．．．

funa（）;

   ．．．

｝

还有些数据结构如二叉树，结构本身固有递归特性；此外，有一类问题，其本身没有明显的递归结构，但用递归程序求解比其他方法更容易编写程序，如八皇后问题、汉诺塔问题等。

    正因为递归程序的普遍性，我们应该学会使用递归来求解问题。直接递归程序与间接递归中都要实现当前层调用下一层时的参数传递，并取得下一层所返回的结果， 并向上一层调用返回当前层的结果。至于各层调用中现场的保存与恢复，均由程序自动实现，不需要人工干预。因此，在递归程序的设计中关键是找出调用所需要的 参数、返回的结果及递归调用结束的条件。如在阶乘函数Fact(n)中，各层要求传递一个自然数n，返回n* Fact(n-1)，递归调用结束的条件是n=0；据此，可以方便地写出它的对应程序（Java语言）：

    Class ClassFact

    {     public  static  long  Fact ( int n )

          {

             if (n==0)        return 1；

             return n*Fact(n - 1)；

       }

}

在一些稍微复杂的问题中，依据上述方法也可以方便地写出递归程序，下面结合旅行家问题谈谈递归的实现。

    旅行家问题：旅行家要旅行N个城市，要求各个城市经历且仅经历一次，并要求所走的路程最短。该问题又称为货郎担问题、邮递员问题，是有名的N-P难题。在N很大时，并不采用本文所用的递归遍历方法，而是采用神经网络、遗传算法等方法得到问题的解。

    要得到N个城市依次经历的最短路径，应把各个对N个城市的遍历所经过的路程相比较，选出其中的最小值作为返回结果。当N比较小时，若N固定，可以用循环实现对N（N=3）个城市的遍历，如下所示：

Class Cities

{     

    private int[][] cities = {{1,23}, {45,68}, {34,26}}；//各城市表示为（X,Y）X,Y为0到99之间的值

private long shortestLength = 1000000；//可能的最大路程

private long getLength(int i，int j，int k)

{．．．}    //计算以i j k为经历顺序的路程


   public int[] getShortestPath()

   {

      int[] shortestPath = new int[3]；

      for(int i=0； i<3； i++)

      {

         for(int j=0； j<3； j++)

         {

            if (j==i)   continue；

            for(int k=0； k<3； k++)

            {

               if (k==j) | | (k==i)   continue；

                  //计算以i ，j， k为经历顺序的路程

long  tempLength = getLength(I，j，k)；

     //更新最短路程、经历顺序

        if  (tempLength < shortestLength)

               {

           shortestLength = tempLength；

                  shortestPath[0] = i；

                  shortestPath[1] = j；

                  shortestPath[2] = k；

               }     // End if

            }            // End for k

          }                   // End for j

        }                          // End for i

    return shortestPath；

}

显然，当N变化时，要重新编写程序。因此考虑使用递归程序实现对N可变时的求解。

    用递归程序解决旅行家问题时，思路与循环方法一样：找出各种可能的经历顺序，比较在各个顺序下所走的路程，从中找出最短路程所对应的经历顺序。在该问题的 递归调用中，当前层对上一层传递的已经经历的城市进行判断，以决定是否已经遍历，若已遍历，则结束本次调用并向上一层返回；若未结束，则选择一个未经历的 城市经历，再把经历信息传递给下一层。在这里，第n层调用传入的参数可以看成已经遍历的城市和已确定的最短路程，返回的结果可以看成更新的经历顺序和最短 路程（若n<N则n层未遍历所有城市，此时可以认为该层得到的最短路程为无穷大，不更新最短路程）。

在Java中定义一个类

Class Cities

{

private int[][] cities; //各城市表示为（X,Y）X,Y为0到99之间的值

private int[] shortestPath;//保存最短路程对应的经历顺序

private int num;          //保存N（城市个数）

private long  shortestLength = 100000000;//N个城市遍历时可能最大路程

private long getLength(int[] tPath) {．．．}    //计算以tPath为经历顺序的路程

public  Cities(int n)              //构造n个城市的坐标，假设为0到99之间的随机数

{     

．．．

}     

public int[] getShortestPath()                      //获得最短路径

{

   int[] tempPath = new int[num];

   shortestPath = new int[num];

int[] citiesToured = new int[num];   //保存第I个城市是否已经经历

       int  citiesNum = 0;              //已经经历城市的个数

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

         citiesToured[i] = 0;


goThrough(tempPath, citiesNum, citiesToured);//遍历各城市

  

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

         tempPath[i] = shortestPath[i];    //得到遍历顺序

return tempPath;                              //返回结果

}

  

private void goThrough(int[] tPath, int cNum, int[] cToured)     //遍历N个城市

{

       if (cNum == 0)                           //无经历城市时，选择第1个城市

       {

          cNum++;

          tPath[0] = 0；

          cToured[0] = 1；

          goThrough(tPath, cNum, cToured)；

        }

        else if (cNum == num)                //各个城市已经经历，结束

       {

          long tempLength = getLength(tPath)；//计算此经历顺序所走的路程

                     

      if (tempLength < shortestLength)         //比较路程

         {

            shortestLength = tempLength；    //更新最短路程及其经历顺序

            for(int i=0； i<num； i++)

              shortestPath[i] = tPath[i]；

         }

        }

        else                  

        {

          for(int i=0； i<num； i++)

            if (cToured[i] != 1)                             //选择未经历的城市

            {

              cToured[i] = 1;  //加入已经历城市

              tPath[cNum]= i;

              cNum++;           //已经历城市个数+1

              goThrough(tPath,cNum, cToured);//调用下一层

              cToured[i] = 0;   //恢复本层的状态：

              cNum--;           //已经历城市及个数

              }                 //End if in for(i)

          }                     //End else

       }      

private long getLength(int[] tPath)        //以指定顺序计算遍历路程

{

long  length = 0;           //路程

    int nowPoint = 0;          //当前城市，第一次取0

    for(int i=1; i<num; i++)

    {

      int j = tPath[i];

length+=(long)Math.sqrt((cities[j][0]-cities[nowPoint][0])*(cities[j][0]- cities[nowPoint][0])+(cities[j][1]-cities[nowPoint][1])*(cities[j][1]-cities [nowPoint][1]));//加上当前、下一城市间的距离

      nowPoint = j;      //更新当前城市

}

length+=(long)Math.sqrt((cities[0][0]-cities[nowPoint][0])*(cities[0][0]-cities[nowPoint][0])                                +(cities[0][1]-cities[nowPoint][1])*(cities[0][1]-cities[nowPoint][1])); //加上首尾城市间的距离

  return length;

  }

}                          // Cities类定义结束

这样通过使用递归，实现了对N可变时问题的求解。

由于递归过程结构清晰，程序易读，而且正确性容易得到验证。因此，利用允许递归的语言如Pascal 、C(++) 等进行程序设计时，给用户编制程序和调试程序带来很大的方便。但同时，由于递归调用过程中要保存大量的实参、局部变量，及程序控制的保存与恢复。因此，递 归程序运行的效率比较低，占用内存多，执行时间长，如果能在程序中消除过程的递归调用，肯定可以提高程序的时空效率。另一方面，并非一味地消除递归，因为 在一些情况下，程序结构简单、可读性强比运行效率高更具有意义。