11.13学习笔记

1.判断二叉搜索树后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        vector<int> left, right;
        int pos = 0, end = sequence.size()-1;
        if(end == -1) return false;
        if(end == 0) return true;
        while(pos<end)
        {
            if(sequence[pos] > sequence[end]) break;
            left.push_back(sequence[pos]);
            pos++;
        }
        while(pos<end)
        {
            if(sequence[pos] < sequence[end]) return false;
            right.push_back(sequence[pos]);
            pos++;
        }
        if(left.size() == 0) return VerifySquenceOfBST(right);
        if(right.size() == 0) return VerifySquenceOfBST(left);
        return VerifySquenceOfBST(left) && VerifySquenceOfBST(right);
    }
};

二叉搜索树是左<根<右，所以后序遍历最后一个元素即根，小于根的是左子树，大于根的是右子树，利用这个点递归。

有一个小问题，刚开始如果树为零的话，需要直接判负，但是如果后续再有空左右子树的话，又需要返回true，解决这个小矛盾的方法就是函数的最后加上个判断，如果子树为零则直接不检测就行了，只检测另一个子树。

2.register寄存器变量

当一个变量频繁被读写时，需要反复访问内存，花费大量存取时间，这时候就需要用到寄存器变量。这种变量放在CPU的寄存器中，使用时不需要访问内存，直接从寄存器中读写，提高效率。不过只有局部自动变量和形参才可以定义为寄存器变量。

register只是一个建议型关键字，能不能生命成功还取决于编译器，比如inline。

register变量无法被取地址，因为内存有地址而寄存器无地址。

3.字符串转double

/* Convert a string to a double.  */  
double  
atof (const char *nptr)  
{  
  return strtod (nptr, (char **) NULL);  
}  
/*

   这个函数是把浮点数字符串转换为浮点数的函数。

   函数将会跳过字符串中的空格字符和不是'+'、'-'、'.'、

   数字的字符。如果字符串是空的或者都是由空格组成，将不会

   做任何转换，仅仅是把字符串的结束地址赋给endptr。如果字

   符串合法，将会进行转换，并把字符串最后的NULL的地址给

   endptr。如果你想使用endptr参数，那么赋一个NULL值就

   可以了。

*/

double my_strtod(const char* s, char** endptr)

{

   register const char*  p     = s;

    register long double  value = 0.L;

    int                   sign  = 0;

    long double           factor;

    unsigned int          expo;

  

    while ( isspace(*p) )//跳过前面的空格

      p++;

 

    if(*p == '-' || *p == '+')

      sign = *p++;//把符号赋给字符sign，指针后移。

  

   //处理数字字符

 

    while ( (unsigned int)(*p - '0') < 10u )//转换整数部分

      value = value*10 + (*p++ - '0');

   //如果是正常的表示方式（如：1234.5678）

   if ( *p == '.' )

   {

        factor = 1.;

        p++;

        while ( (unsigned int)(*p - '0') < 10u )

      {

         factor *= 0.1;

            value  += (*p++ - '0') * factor;

        }

    }

   //如果是IEEE754标准的格式（如：1.23456E+3）

    if ( (*p | 32) == 'e' )

   {

      expo   = 0;

        factor = 10.L;

        switch (*++p)

      {

        case '-':

           factor = 0.1;

        case '+':

           p++;

           break;

        case '0':

        case '1':

        case '2':

        case '3':

        case '4':

        case '5':

        case '6':

        case '7':

        case '8':

        case '9':

           break;

        default :

           value = 0.L;

           p     = s;

           goto done;

        }

        while ( (unsigned int)(*p - '0') < 10u )

            expo = 10 * expo + (*p++ - '0');

        while ( 1 )

      {

        if ( expo & 1 )

           value *= factor;

            if ( (expo >>= 1) == 0 )//赋值表达式返回值是左值，就是被赋值的左边变量，也就是右边的运算结果

                break;

            factor *= factor;

        }

    }

done:

    if ( endptr != 0 )

        *endptr = (char*)p;

 

    return (sign == '-' ? -value : value);

}

double my_atof(char *str)

{

   return my_strtod(str,0);

}

int main()

{

   char * str = "12345.6789";

   printf("%f/n",my_strtod(str,0));

   printf("%f/n",my_atof(str));

  

   str = "-12345.6789";

   printf("%f/n",my_strtod(str,0));

   printf("%f/n",my_atof(str));

 

   str = "9.8546721E+4";

   printf("%f/n",my_strtod(str,0));

   printf("%f/n",my_atof(str));

 

   str = "-985467.21e-4";

   printf("%f/n",my_strtod(str,0));

   printf("%f/n",my_atof(str));

  

   system("pause");

   return 0;

}

4.二叉树路径

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
    vector<vector<int> > res;
    vector<int> sav;
    void dfs(TreeNode* root, int sum)
    {
        sav.push_back(root->val);
        if(root->val == sum && !root->left && !root->right)
        {
                res.push_back(sav);
        }
        else
        {
            if(root->left) dfs(root->left, sum-root->val);
            if(root->right) dfs(root->right, sum-root->val);
        }
        sav.pop_back();
    }
    
public:
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root) dfs(root, expectNumber);
        return res;
    }
};