递归和分治策略

汉诺塔问题的递归解决

void Hanoi(int n,int A,int B,int C)
{
    if(n>0)
    {
        hanoi(n-1,A,C,B);
        move(n,A,C);
        hanoi(n-1,B,A,C);
    }
}

汉诺塔问题的非递归方式解决

void Hanoi(int n)
{
    ElementType P,ToPush;
    Stack S;

    P.N = n; P.A = 'a'; P.B = 'b'; P.C = 'c';
    S.Top = -1;

    Push(&S,P);
    while(S.Top != -1)
    {
        if(P.N == 1){
            printf("%c -> %c\n",P.A，P.C);
        }
        else
        {
            ToPush.N = n-1;
            ToPush.A = P.A;ToPush.B = P.C;ToPush.C = P.B;
            Push(&S,ToPush);
            ToPush.N = 1;
            ToPush.A = P.A;ToPush.B = P.B;ToPush.C = P.C;
            Push(&S,ToPush);
            ToPush.N = n-1;
            ToPush.A = P.B;ToPush.B = P.A;ToPush.C = P.B;
            Push(&S,ToPush);
        }
    }
}

汉诺塔的非递归实现使用了数据结构中的堆栈
将最后需要解决的子问题压入到堆栈中

二分查找
BinarySearch python实现

def search(L,e):
    def bSearch(L,e,low,high):
        if (low == high):
            return L[low] == e
        mid = low + int((high-low)/2)
        if (L[mid] == e):
            return True
        elif (L[mid] < e):
            return bSearch(L,e,mid+1,high)
        else:
            return bSearch(L,e,low,mid-1)
    if(len(L) == 0):
        return False
    else:
        return bSearch(L,e,0,len(L)-1)