二叉树打印

1、按层次遍历书并打印，要求遍历完一层后换行
解决方法：利用一个队列qe和两个变量last和nlast

• qe中存储了当前层和下一层的部分节点
• last标记当前层的最后一个节点
• nlast标记下一层的最后一个节点
  c++版代码如下：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
#include <queue>
class TreePrinter {
public:
    vector<vector<int> > printTree(TreeNode* root) {
        // write code here
        vector<vector<int>> vec;
        TreeNode *last = root;
        TreeNode *nlast = NULL;
        TreeNode *node;
        queue<TreeNode*> qe;
        if(root == NULL )
            return vec;
        vector<int> temp;
        qe.push(last);
        while(! qe.empty()){
            node = qe.front();
            temp.push_back(node->val);
            qe.pop();
            if(node->left){
                nlast = node->left;
                qe.push(nlast);
            } 
            if(node->right){
                nlast = node->right;
                qe.push(nlast);
            } 
            if(node == last){
                vec.push_back(temp);
                temp.clear();
                last = nlast;
            }
        }
        return vec;
    }
};

2、二叉树的序列化和反序列化，分为先序，中序和后序三种
例如二叉树
1
2 3
4 5 6
7 8 9 10
的先序遍历序列为：
1！2！4！7！#！#！8！#！#！5！#！#！3！#！6！9！#！#！10！#！#！
其实就是先序（中序、后序）序列中，空节点用#占位，每个节点用！分割。

字符串

3、逆序（给出一个句子，将句子中的单词逆序）
解决方法：局部逆序技巧

• 1、将整个句子逆序
• 2、将句子中的每个单词逆序
  4、0~i的字符串移动到最右面
  解决方法：局部逆序技巧
• 1、将0~i的字符串逆序。
• 2、将i + 1~length(str) - 1的字符串逆序。
• 3、将整个字符串逆序。
  5、判断str1是不是str2的旋转词（0~i的字符串移动到最右面之后得到的词）
• 1、求str = str2 + str2的大字符串
• 2、判断str1和str2是否等长
• 3、若等长判断str是否是str的一部分
  6、字符串拼接后按字典顺序排序
  解决方法：通过两两比较（将两两拼接后的字符串按字典顺序排序靠前的字符串中的前面的字符串排在前面）将字符串排序（O(N)*O(log(N))）。
  两串旋转练习题
  如果对于一个字符串A，将A的前面任意一部分挪到后边去形成的字符串称为A的旋转词。比如A="12345",A的旋转词有"12345","23451","34512","45123"和"51234"。对于两个字符串A和B，请判断A和B是否互为旋转词。

给定两个字符串A和B及他们的长度lena，lenb，请返回一个bool值，代表他们是否互为旋转词。

测试样例：
"cdab",4,"abcd",4
返回：true

class Rotation {
public:
    bool chkRotation(string A, int lena, string B, int lenb) {
        // write code h ere
        //将字符串变为字符数组
        char aa[1000];
        string AA = A + A;
        int length_aa = AA.copy(aa, 999);
        aa[length_aa] = '\0';
        
        char bb[1000];
        string BB = B + B;
        int length_bb = BB.copy(bb, 999);
        bb[length_bb] = '\0';
        
        char a[1000];
        int length_a = A.copy(a, 999);
        a[length_a] = '\0';
        
        char b[1000];
        int length_b = B.copy(b, 999);
        b[length_b] = '\0';
        //此处为了证明AB互为旋转词，进行了两遍测试，实际上，只要A是B的旋转词，则B就一定是A的旋转词
        return getIndexof(aa, b, lena, lenb) && getIndexof(bb, a, lenb, lena);
    }
    bool getIndexof(char ab[], char a[], int lena, int lenb){    
        int i, j = 0, index = 0, mark = 0;
        if(lena != lenb)
            return false;
        else{
            
            for(i = 0; i < lena + lenb; i++){
                if(ab[i] == a[j]){
                    index = i;
                    mark = 1;
                }
                while(ab[i] == a[j]){
                    i++;
                    j++;
                    if(i >= lena + lenb || j >= lena)
                        break;
                }
                if(j >= lena){
                    return true;
                }
                else if(i >= lena + lenb){
                    return false;
                }
                //如果部分匹配，则需要回退主串索引
                if(mark == 1){
                    i = index;
                }
                mark = 0;
                //每次循环都要置目标串索引为0
                j = 0;
                
            }
            return false;
        }
    }
};