1.自定義實現字串轉為整數的演算法，例如把“123456”轉成整數123456.(輸入中可能存在符號，和數字)

//返回結果的有效標誌  
enum Status {VALID,IN_VALID};  
int gStatus = VALID;  
  
int strToInt(const char* str)  
{  
    long long result = 0;//儲存結果  
    gStatus = IN_VALID; //每次呼叫時都初始化為IN_VALID  
    if(str != NULL)  
    {  
        const char* digit = str;  
  
        bool minus = false;  
  
        if(*digit == '+')  
            digit++;  
        else if(*digit == '-')  
        {  
            digit++;  
            minus = true;  
        }  
  
        while(*digit != '\0')  
        {  
            if(*digit >= '0' && *digit <= '9')  
            {  
                result = result * 10 + (*digit -'0');  
                //溢位  
                if(result > std::numeric_limits<int>::max())  
                {  
                    result = 0;  
                    break;  
                }  
                digit++;  
            }  
  
            //非法輸入  
            else  
            {  
                result = 0;  
                break;  
            }  
        }  
  
        if(*digit == '\0')  
        {  
            gStatus = VALID;  
            if(minus)  
                result = 0 - result;  
        }  
    }  
  
    return static_cast<int>(result);  
}  
 

思路：先利用前序和中序構建出二叉樹，然後後序遍歷輸出結果

/** 
*返回二叉樹的根節點 
*preOrder:前序遍歷序列 
*inOrder:中序遍歷序列 
*len:節點數目 
*/  
Node* getBinaryTree(char* preOrder, char* inOrder, int len)  
{  
    if(preOrder == NULL || *preOrder == '\0' || len<=0)  
        return NULL;  
  
    Node* root = (Node*) malloc(sizeof(Node));  
    if(root == NULL)  
        exit(EXIT_FAILURE);  
  
    //前序遍歷的第一個節點就是根節點  
    root->data = *preOrder;  
  
    int pos = 0;//找到根節點在中序遍歷中的位置，其值也代表了左子樹的節點數目  
    while(true)  
    {  
        if(*(inOrder+pos) == root->data)  
            break;  
        pos++;  
    }  
  
    //通過遞迴找到左子樹和右子樹，注意子樹的前序中序的下標的計算  
    if(pos == 0)  
        root->lchild = NULL;  
    else  
        root->lchild = getBinaryTree(preOrder+1, inOrder, pos);  
  
    if(len-pos-1 == 0)  
        root->rchild = NULL;  
    else  
        root->rchild = getBinaryTree(preOrder+pos+1, inOrder+pos+1,len-pos-1);  
    return root;  
}  
  
/** 
*後續遍歷二叉樹 
* 
*/  
void postOrder(Node* root)  
{  
    if(root == NULL)  
        return;  
  
    postOrder(root->lchild);  
    postOrder(root->rchild);  
    printf("%c", root->data);  
}  
  
/** 
*根據前序遍歷和中序遍歷輸出後續遍歷 
* 
*/  
void printPostOrderViaPreOrderAndInorder(char* preOrder, char* inOrder)  
{  
    Node* root = getBinaryTree(preOrder, inOrder, strlen(preOrder));  
    postOrder(root);  
}  
 

一是利用數學知識，從左上角到右下角總共要走2n步，其中橫向要走n步，所以總共就是C2n~n。

二是利用遞迴實現

/** 
*返回總路徑數 
*引數m:表示矩形的橫向格子數 
*引數n:表示矩形的縱向格子數 
*/  
int getTotalPath(int m, int n)  
{  
    //如果橫向格子數為1，則類似“日”字，此時路徑數為縱向格子數加1  
    if(m == 1)  
        return n + 1;  
    //如果縱向格子數為1，此時路徑數為橫向格子數加1  
    if(n == 1)  
        return m + 1;  
  
    //由於從當前點出發，只能向右或向下移動：  
    //向右移動，則接下來就是getTotalPath(m-1, n)的情形  
    //向下移動，則接下來就是getTotalPath(m, n-1)的情形  
    return getTotalPath(m-1, n) + getTotalPath(m, n-1);  
}  
 

轉載請註明原創連結：http://blog.csdn.net/wujunokay/article/details/12209183