备战练习（四)

一、回文数索引

#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
 
bool IsHui(const string& str) {
    if(str.size() == 0) {
        return true;
    }
     
    int begin = 0;
    int end = str.size() - 1;
    while(begin < end) {
        if(str[begin] != str[end]) {
            return false;
        }
        begin++;
        end--;
    }
    return true;
}
 
int main() {
     
    int n = 0;
     
    while(cin >> n) {
        vector<string> vec;
        vec.resize(n);
         
        for(auto& vit : vec) {
            cin >> vit;
        }
         
        for(int i = 0; i < n; i++) {
             
            if(IsHui(vec[i])) {
                cout << -1 << endl;
                continue;
            }
           
             
            int begin = 0;
            int end = vec[i].size() - 1;
            while(begin < end) {
                if(vec[i][begin] != vec[i][end]) {
                    //有偏差
                    string tmp = vec[i];
                    tmp.erase(tmp.begin() + begin);
                   // cout << tmp << endl;
                    if(IsHui(tmp)) {
                        //如果是回文
                        cout << begin << endl;
                        break;
                    }
                     
                    tmp = vec[i];
                    tmp.erase(tmp.begin() + end);
                //                cout << tmp << endl;
                    if(IsHui(tmp)) {
                        //如果是回文
                        cout << end << endl;
                        break;
                    }
                }
                begin++;
                end--;
            }
        }
    }
     
     
}

二、把数组排成最小的数

字典序排序， ab < ac， aad > aac

class Solution {
public:
     
    static bool cmp(int a, int b) {
        string str1 = to_string(a);
        string str2 = to_string(b);
         
        string A = str1;
        A += str2;
        string B = str2;
        B += str1;
         
        return A < B;     //小于
    }
     
    string PrintMinNumber(vector<int> numbers) {
         
        string str;
        if(numbers.size() == 0) {
            return str;
        }
         
        sort(numbers.begin(), numbers.end(), cmp);
        for(const auto& vit : numbers) {
            str += to_string(vit);
        }
         
        return str;
    }
};

三、数组中只出现一次的数字

位运算

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
         
        if(data.size() == 0) {
            return;
        }
         
        int sum = data[0];
        for(int i = 1; i < data.size(); i++) {
            sum ^= data[i];
        }
      //  cout << "sum:" << sum << endl;
        //sum值为这两个值异或的值
        //拆分
        int flag = 1;
        for(int i = 0; i < 32; i++) {
            if((flag << i) & sum) {
                //找到了sum中从右向左第一位为1的下标
                //退出        
                flag <<= i;
                break;
            }
        }
      //  cout << "flag:" << flag << endl;
         
        *num1 = 0;
        *num2 = 0;
        for(int i = 0; i < data.size(); i++) {
            if(flag & data[i]) {
                *num1 ^= data[i];
            }
            else {
                *num2 ^= data[i];
            }
        }
    }
};

四、左旋转字符串

单独设置一个函数左旋一次。
判断需要左旋几次， 然后调用几次这样的函数就可以了。

class Solution {
public:
     
    void LeftRotateStringHalper(string& str) {
        //左旋一次
        int key = str[0];
        int i = 0;
        for(i; i < str.size() - 1; i++) {
            str[i] = str[i + 1];
        }
        str[i] = key;
    }
     
    string LeftRotateString(string str, int n) {
        if(str.size() == 0) {
            return str;
        }
         
        n = n % str.size();
        while(n >= 1) {
            LeftRotateStringHalper(str);
            n--;
        }
        return str;
    }
};

五、翻转单词顺序列

1、整体反转
2、部分反转

class Solution {
public:
    string ReverseSentence(string str) {
        if(str.size() == 0) {
            return str;
        }
         
        //整体翻转
        reverse(str.begin(), str.end());
        int begin = 0;
        int end = 0;
         
        while(end != str.size()) {
            end = begin;
            while(str[end] != ' ' && str[end] != '\0') {
                end++;
            }
            reverse(str.begin() + begin, str.begin() + end);
            begin = end + 1;          
        }
         
        return str;
    }
};

六、二叉树的之字形层序遍历

层序遍历的思想。

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 * };
 */
 
class Solution {
public:
    /**
     *
     * @param root TreeNode类
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > zigzagLevelOrder(TreeNode* root) {
        // write code here
         
        vector<vector<int>> vec;
        if(!root) {
            return vec;
        }
         
        queue<TreeNode*> qe;
 
        int flag = 1;    //1正向， -1反向
        qe.push(root);
         
        while(!qe.empty()) {
            int size = qe.size();
            vector<int> vec_tmp;
            vec_tmp.reserve(size);
            for(int i = 0; i < size; i++) {
                TreeNode* tmp = qe.front();
                qe.pop();
                if(tmp->left) { qe.push(tmp->left); }
                if(tmp->right) { qe.push(tmp->right); }
                vec_tmp.push_back(tmp->val);
            }
             
            if(flag == 1) {
                //正向输出
                vec.push_back(vec_tmp);
                flag = -1;
            }
            else if(flag == -1) {
                reverse(vec_tmp.begin(), vec_tmp.end());
                vec.push_back(vec_tmp);
                flag = 1;
            }
             
        }
         
        return vec;
    }
};

七、二叉搜索树的第k个结点

二叉搜索树特性了解，
中序遍历

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    TreeNode* KthNode(TreeNode* pRoot, int k)
    {
        if(!pRoot) {
            return nullptr;
        }
         
        stack<TreeNode*> st;
        int count = 0;
        TreeNode* cur = pRoot;
         
        while(cur || !st.empty()) {
            //把cur结点所有左结点入栈
            while(cur) {
               st.push(cur);
               cur = cur->left;
            }
             
            TreeNode* tmp = st.top();
            st.pop();
            count++;
            if(count == k) {
                return tmp;
            }
             
            if(tmp->right) {
                cur = tmp->right;
            }
        }
           
        return nullptr;
         
    }
 
     
};