Logo GBNhost.com — скидка на VPS сервера 50 процентов! Море(!) аналитической информации!
IT-консалтинг Software Engineering Программирование СУБД Безопасность Internet Сети Операционные системы Hardware
Бесплатный конструктор сайтов и Landing Page

Хостинг с DDoS защитой от 2.5$ + Бесплатный SSL и Домен

SSD VPS в Нидерландах под различные задачи от 2.6$

Ваш идеальный сервер от 4$/мес. Все включено:

- Администрирование и решение проблем 24/7
- Перенос проектов без рисков и простоев.
- Круглосуточный мониторинг доступности сайтов.
- Защита от DDoS атак.

Хостинг в Европе для новичков (от 25 руб/мес) и VIP-хостинг для профессионалов (от 1000 руб/мес)

Скидка 25% на все тарифы хостинга по промокоду STDCITF

Бесплатно: тест на 30 дней!

Сверхбыстрый хостинг от 69 р./мес., VPS от 299 р./мес.

Бесплатно: администрирование + ISPmanager + DDoS защита + SSL + 7 дней тестовый период

Скидка 50% на первый месяц VPS и хостинга по промокоду CITFORUM

2.4. Рекурсия

Функция называется рекурсивной, если во время ее обработки возникает ее повторный вызов, либо непосредственно, либо косвенно, путем цепочки вызовов других функций.

Прямой (непосредственной) рекурсией является вызов функции внутри тела этой функции.


     int a()

     {.....a().....}

Косвенной рекурсией является рекурсия, осуществляющая рекурсивный вызов функции посредством цепочки вызова других функций. Все функции, входящие в цепочку, тоже считаются рекурсивными.

Например:


                    a(){.....b().....}

                    b(){.....c().....}

                    c(){.....a().....} .

Все функции a,b,c являются рекурсивными, так как при вызове одной из них, осуществляется вызов других и самой себя.

Рассмотрим задачу о Ханойских башнях. Имеются три стержня с номерами 1,2,3. На стержень 1 надето n дисков различного диаметра так, что они образуют пирамиду (см.рис.31). Написать программу для печати последовательности перемещений дисков со стержня на стержень, необходимых для переноса пирамиды со стержня 1 на стержень 3 при использовании стержня 2 в качестве вспомогательного. При этом за одно перемещение должен переноситься только один диск, и диск большего диаметра не должен помещаться на диск меньшего диаметра. Доказано, что для n дисков минимальное число необходимых перемещений равно 2^n-1.


Рис.31. Задача о Ханойских башнях.

Для решения простейшего случая задачи, когда пирамида состоит только из одного диска, необходимо выполнить одно действие - перенести диск со стержня i на стержень j, что очевидно (этот перенос обозначается i -> j). Общий случай задачи изображен на рисунке, когда требуется перенести n дисков со стержня i на стержень j, считая стержень w вспомогательным. Сначала следует перенести n-1 диск со стержня i на стержень w при вспомогательном стержне j, затем перенести один диск со стержня i на стержень j и, наконец, перенести n-1 диск из w на стержень j, используя вспомогательный стержень i. Итак, задача о переносе n дисков сводится к двум задачам о переносе n-1 диска и одной простейшей задаче. Схематически это можно записать так: T(n,i,j,w) = T(n-1,i,w,j), T(1,i,j,w), T(n-1,w,j,i).


                i     n-1     w    n-1       j

         +      |  -------->-+|+--------->+  |

      n-1|      |      I     |||    Ш     |  |

         +     / \           / \            / \

           +-/-----\-+     /     \      +-/-----\-+

         ==+----|----+===/=========\====+----|----+======

                +-------------->-------------+

                              П

          Рис.32. Схема решения задачи о Ханойских башнях.

Ниже приведена программа, которая вводит число n и печатает список перемещений, решающая задачу о Ханойских башнях при количестве дисков n. Используется внутренняя рекурсивная процедура tn(n,i,j,w), печатающая перемещения, необходимые для переноса n дисков со стержня i на стержень j с использованием вспомогательного стержня w при {i,j,w} = {1,3,2}.


   /*                    ханойские башни                    */

   #include 

   main()                                 /*   вызывающая   */

   {   void tn(int, int, int, int);       /*   функция      */

       int n;

       scanf(" %d",&n);

       tn(n,1,2,3);

    }



    void tn(int n, int i, int j, int w)   /*   рекурсивная  */

    {  if (n>1)                           /*   функция      */

        {  tn (n-1,i,w,j);

           tn (1,i,j,w);

           tn (n-1,w,j,i);

         }

        else printf(" \n %d -> %d",i,j);

        return ;

    }

Последовательность вызовов процедуры tn при m=3 иллюстрируется древовидной структурой на рис.33. Каждый раз при вызове процедуры tn под параметры n, i, j, w выделяется память и запоминается место возврата. При возврате из процедуры tn память, выделенная под параметры n, i, j, w, освобождается и становится доступной память, выделенная под параметры n, i, j, w предыдущим вызовом, а управление передается в место возврата.


Рис.33. Последовательность вызовов процедуры tn.

Во многих случаях рекурсивные функции можно заменить на эквивалентные нерекурсивные функции или фрагменты, используя стеки для хранения точек вызова и вспомогательных переменных.

Предположим, что имеется ситуация:


     main()             /* вызывающая  функция  */

     { ...  f() ...}

     f()                /* рекурсивная функция  */

     { ...  f() ...}

Здесь в функции main вызывается рекурсивная функция f. Требуется заменить описание функции f и ее вызова на эквивалентный фрагмент программы, т.е. удалить функцию f.

Пусть рекурсивная функция f имеет параметры Р1,Р2,...,Рs, внутренние переменные V1,V2,...,Vt и в функциях main и f имеется k обращений к функции f. Для удаления такой функции требуются следующие дополнительные объекты:

- переменные AR1,AR2,...,ARs, содержащие значения фактических параметров при вызове функции f (типы переменных должны соответствовать типам параметров Р1,Р2,...,Рs);

- переменная rz для вычисляемого функцией f результата (тип переменных совпадает с типом возвращаемого значения функции f);

- стек, содержащий в себе все параметры и все внутренние переменные функции f, а также переменную lr типа int, для хранения точки возврата, и переменную pst типа указатель, для хранения адреса предыдущего элемента стека;

- указатель dl для хранения адреса вершин стека;

- промежуточный указатель u для операций над стеком;

- k новых меток L1,...,Lk для обозначенных точек возврата;

- метка jf, используемая для обхода модифицированного тела функции f;

- промежуточная переменная l типа int для передачи номера точки возврата.

Чтобы получить эквивалентную нерекурсивную программу без функции f, необходимо выполнить следующие действия:

1. Убрать объявление функции f в функцию main;

2. Добавить в функции main объявления переменных AR1,AR2,...,ARs,RZ, объявления стека ST и указателей dl и u:


      typedef struct st { P1;P2;...;Ps;V1;V2;...;Vt;

                          int lr;  struct st *pst  }  ST;

      ST *dl=NULL, *u;

3. Модифицировать тело функции f во фрагмент программы. Для этого следует:

а) удалить заголовок функции f;

б) объявления параметров и внутренних переменных и заменить фрагментом:


               goto jf;

            f: a=malloc(sizeof(ST));

               a->P1=AR1; a->P2=AR2; ... ;a->Ps=ARs;

               a->lr=l; a->pst=dl;  dl=a;

в) в конце функции f поставить метку JF, а все обращения к формальным аргументам заменить обращением, к соответствующим элементам стека;

г) вместо каждого оператора return(y) в функции f записать фрагмент:


               RZ=y; l=dl->lr;

               a=dl; dl=a->pst; free(a);

               switch(l)

               { case 1: goto L1;

                 case 2: goto L2;

                        ...

                 case k: goto Lk;

               }

4. Каждый i-тый вызов функции f (как в вызывающей функции, так и в теле функции f) вида V=f(A1,A2,...,As) заменить фрагментом программы :


     AR1=A1; AR2=A2; ... ; ARs=As;  l=i;  goto f;

     Li:  V=RZ;

где l=i обозначает l=1 при первом обращении к функции f, l=2 при втором обращении и т.д. Нумерация обращений может быть выполнена в произвольном порядке и требуется для возвращения в точку вызова с помощью операторов switch и goto Li; (где Li есть L1 при первой замене, Li есть L2 при второй замене и т.д.)

5. Вставить модифицированное тело функции f в конце функции main.

Для иллюстрации изложенного рассмотрим несколько вариантов реализации программы вычисляющей функцию Аккермана, которая определяется так:


              + X+1,                 если N=0

              | X,                   если N=1,  Y=0,

              | 0,                   если N=2,  Y=0,

    A(N,X,Y)= | 1,                   если N=3,  Y=0,

              | 2,                   если N=>4, Y=0,

              + A(N-1,A(N,X,Y-1),X), если N#0,  Y#0;



     где N,X,Y - целые неотрицательные числа.

Следующая программа вычисляет функцию Аккермана с использованием рекурсивной функции ackr и вспомогательной функции smacc:


       /*      рекурсивное  вычисление функции Аккермана     */

       # include 

       main ()                           /*  вызывающая     */

       {   int x,y,n,t;                  /*  функция         */

           int ackr(int, int, int);

           scanf("%d %d %d",&n,&x,&y);

           t=ackr(n,x,y);

           printf("%d",t);

       }

      int smacc( int n,int x )          /*  вспомогательная  */

      {   switch (n)                    /*   функция         */

           {  case 0:  return(x+1);

              case 1:  return (x);

              case 2:  return (0);

              case 3:  return (1);

              default: return (2);

            }

      }

      int ackr( int n, int x, int y)    /*  рекурсивная      */

      {  int z;                         /*  функция          */

         int smacc( int,int);

         if(n==0 || y==0)  z=smacc(n,x);

         else { z=ackr(n,x,y-1);        /*  рекурсивные      */

                z=ackr(n-1,z,x);  }     /*  вызовы ackr(...) */

         return z;

      }

Модифицируя функции main и ackr в соответствии с изложенным методом получим следующую программу:


      /*       Эквивалентная нерекурсивная программа       */

      /*       для вычисления функции Аккермана            */

     #include 

     #include 

     int main()

     {  typedef struct st

        { int i,j,k,z,lr;

          struct st *pst;

        } ST;

        ST *u, *dl=NULL;

        int l,x,y,n;

        int  smacc(int,int);

        int an,ax,ay,rz,t;

        scanf("%i %i %i",&n,&x,&y);



        an=n;ax=x;ay=y;l=1;       /*  -   замена вызова    -  */

        goto ackr;                /*     t=ackr(n,x,y);       */

    l1: t=rz;                     /*  -  -  -  -  -  -  -  -  */



        printf("\n %d ",t);

        goto jackr;



        /*    начало фрагмента заменяющего функцию  ackr      */

    ackr:

        u=( ST *) malloc( sizeof (ST) );

        u->i=an;

        u->j=ax;

        u->k=ay;

        u->lr=l;

        u->pst=dl;

        dl=u;

        if (an==0||ay==0)

        dl->z=smacc(an,ax);

        else

             {

                an=dl->i;         /*  -   замена вызова    -  */

                ax=dl->j;         /*                          */

                ay=dl->k-1;       /*     z=ackr(n,x,y-1);     */

                l=2;              /*                          */

                goto ackr;        /*                          */

           l2:  dl->z=rz;         /*  -  -  -  -  -  -  -  -  */



                an=dl->i-1;       /*  -   замена вызова    -  */

                ax=rz;            /*                          */

                ay=dl->j;         /*     z=ackr(n-1,z,x);     */

                l=3;              /*                          */

                goto ackr;        /*                          */

           l3:  dl->z=rz;         /*  -  -  -  -  -  -  -  -  */

             }

        rz=dl->z;                 /*  -  -  -  -  -  -  -  -  */

        an=dl->i;                 /*                          */

        ax=dl->j;                 /*       замена             */

        ay=dl->k;                 /*                          */

        l=dl->lr;                 /*       оператора          */

        u=dl;                     /*                          */

        dl=u->pst;                /*       return z ;         */

        free(u);                  /*                          */

        switch(l)                 /*                          */

             {  case 1: goto l1;  /*                          */

                case 2: goto l2;  /*                          */

                case 3: goto l3;  /*                          */

             }                    /*  -  -  -  -  -  -  -  -  */

     jackr:

     }

     int smacc( int n,int x )      /* вспомогательная функция */

     {  switch (n)

             { case 0:  return(x+1);

               case 1:  return (x);

               case 2:  return (0);

               case 3:  return (1);

               default: return (2);

             }

     }

[ Назад | Оглавление ]

хостинг сайтов ГиперХост — хостинг сайтов который Вы искали.

Виртуальный хостинг, Аренда VPS серверов, рация доменных имен, SSL сертификаты

Новости мира IT:

Архив новостей

Последние комментарии:

IT-консалтинг Software Engineering Программирование СУБД Безопасность Internet Сети Операционные системы Hardware

Информация для рекламодателей PR-акции, размещение рекламы — adv@citforum.ru,
тел. +7 985 1945361
Пресс-релизы — pr@citforum.ru
Обратная связь
Информация для авторов
Rambler's Top100 TopList liveinternet.ru: показано число просмотров за 24 часа, посетителей за 24 часа и за сегодня This Web server launched on February 24, 1997
Copyright © 1997-2000 CIT, © 2001-2019 CIT Forum
Внимание! Любой из материалов, опубликованных на этом сервере, не может быть воспроизведен в какой бы то ни было форме и какими бы то ни было средствами без письменного разрешения владельцев авторских прав. Подробнее...