关与一摞饼的排序，代码好难理解，跪求解释,该怎么处理

关与一摞饼的排序，代码好难理解，跪求解释
/*1-8.h*/
#include <stdio.h>
#include <assert.h>

class CPrefixSorting
{
public:
CPrefixSorting()
{
m_nCakeCnt = 0;
m_nMaxSwap = 0;
}

~CPrefixSorting()
{
if(m_CakeArray != NULL)
delete m_CakeArray;
if(m_SwapArray != NULL)
delete m_SwapArray;
if(m_ReverseCakeArray != NULL)
delete m_ReverseCakeArray;
if(m_ReverseCakeArraySwap != NULL)
delete m_ReverseCakeArraySwap;
}

void Run(int* pCakeCnt, int nCakeCnt)
{
Init(pCakeCnt, nCakeCnt);

m_nSearch = 0;
Search(0);
}

void Output()
{
for(int i = 0; i < m_nMaxSwap; i++)
printf("%d ", m_SwapArray[i]);

printf("\n");

for(int i = 0; i < m_nCakeCnt; i++)
printf("%d ", m_ReverseCakeArray[i]);

printf("\n |Search Times| : %d\n", m_nSearch);
printf("Total Swap times = %d\n", m_nMaxSwap);
}
private:

//初始化成员变量
void Init(int* pCakeCnt, int nCakeCnt)
{
assert(pCakeCnt);
assert(nCakeCnt > 0);

m_nCakeCnt = nCakeCnt;

//初始化饼的数组
m_CakeArray = new int[m_nCakeCnt];
assert(m_CakeArray);
for(int i = 0; i < m_nCakeCnt; i++)
m_CakeArray[i] = pCakeCnt[i];

//设置最多交换次数信息
m_nMaxSwap = UpperBound(m_nCakeCnt);

//初始化交换结果数组
m_SwapArray = new int[m_nMaxSwap + 1];
assert(m_SwapArray);

//初始化中间交换结果信息
m_ReverseCakeArray = new int[m_nCakeCnt];
for(int i = 0; i < m_nCakeCnt; i++)
{
m_ReverseCakeArray[i] = m_CakeArray[i];
}
m_ReverseCakeArraySwap = new int[m_nMaxSwap];
}

//寻找翻转的上界
int UpperBound(int nCakeCnt)
{
return 2 * nCakeCnt;
}

//寻找当前翻转的下界
int LowerBound(int* pCakeCnt, int nCakeCnt)
{
int t, ret = 0;
for(int i = 1; i < nCakeCnt; i++)
{
t = pCakeCnt[i] - pCakeCnt[i-1];
if((t == 1)||(t == -1))
{
}
else
ret++;
}
return ret;
}

//排序的主函数
void Search(int step)
{
int i, nEstimate;

m_nSearch++;

//估算这次搜索所需要的最小交换次数
nEstimate = LowerBound( m_ReverseCakeArray, m_nCakeCnt);
if(step + nEstimate > m_nCakeCnt)
return;

//如果已经排好序，即翻转完成，输出结果
if(IsSorted(m_ReverseCakeArray, m_nCakeCnt))
{
if(step < m_nMaxSwap)
{
m_nMaxSwap = step;
for(i = 0; i < m_nMaxSwap; i++)
m_SwapArray[i] = m_ReverseCakeArraySwap[i];
}
return;
}

//递归进行翻转
for(i = 1; i < m_nCakeCnt; i++)
{
Reverse(0, i);
m_ReverseCakeArraySwap[step] = i;
Search(step + 1);
Reverse(0, i);
} }


//检测是否排好序
bool IsSorted(int* pCakeArray, int nCakeCnt)
{
for(int i = 1; i < nCakeCnt; i++)
{
if(pCakeArray[i-1] > pCakeArray[i])
return false;
}
return true;
}

//饼的翻转信息
void Reverse(int nBegin, int nEnd)
{
assert(nBegin < nEnd);
int i, j, t;

//翻转饼的信息
for(i = nBegin, j = nEnd; i < j; i++, j--)
{
t = m_ReverseCakeArray[i];
m_ReverseCakeArray[i] = m_ReverseCakeArray[j];
m_ReverseCakeArray[j] = t;
}

// for(i =0; i < m_nCakeCnt; i++)
// printf(" %d ", m_ReverseCakeArray[i]);
}
private:
int* m_CakeArray; //饼的信息数组
int m_nCakeCnt; //饼的个数
int m_nMaxSwap; //最多交换次数。最多是2 * (n - 1)

int* m_SwapArray; //交换结果数组

int* m_ReverseCakeArray; //当前饼的反转信息
int* m_ReverseCakeArraySwap; //当前翻转饼的交换结果
int m_nSearch; //当前搜索次数
};

#include <stdio.h>
#include "1-8.h"
int main()
{
int CakeCnt = 9;
int CakeArray[9] = {3, 2, 1, 6, 5, 4, 9, 8, 0};

class CPrefixSorting a;

a.Run(CakeArray, CakeCnt );
a.Output();

return 0;
}

代码中递归的红色部分，如何解释，哭啊，小弟被搞的头大了两天，还是想不通，跪求解释，越详细越好。

------解决方案--------------------
参见: http://blog.****.net/weixingstudio/article/details/6912434

C/C++ code

for(i = 1; i < m_nCakeCnt; i++)
{
  Reverse(0, i);
  m_ReverseCakeArraySwap[step] = i;
  Search(step + 1);
  Reverse(0, i);
}