32/234/114

32.最长有效括号

class Solution {
public:
    int longestValidParentheses(string s) {
        int maxans=0;
        int n=s.length();
        vector<int> dp(n,0);
        for(int i=1;i<n;i++){
            if(s[i]==')')//只有当）结尾时会存在长度值
            {
                //说明是个成对的，看是否前面也有成对的,没有的话直接为0+2
                if(s[i-1]=='('){
                    dp[i] =(i>=2?dp[i-2]:0)+2;
                }else if(i-dp[i-1]>0&&s[i-dp[i-1]-1]=='('){//直接等于0就说明前面就一对括号，没有相匹配的了
                //那就直接跳过，如果再前面还有一个（,那就得加2，
                //分为两部分，如果再前面存在两个以上的括号，就在那个基础上加2，如果前面没有完整的2个，那么直接在原基础上加2就行
                    dp[i] = dp[i - 1] + (i - dp[i - 1] >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxans = max(maxans, dp[i]);
            }
        }
    return maxans;
    }
};

234.回文链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        //创建数组来存链表的值，然后运用双指针
        vector<int> vals;
        while(head!=nullptr){
            vals.emplace_back(head->val);//比push_back多用内存少
            head=head->next;
        }
        for(int i=0,j=vals.size()-1;i<j;i++,j--){
            if(vals[i]!=vals[j]){
                return false;
            }
        }
        return true;
    }
};

94.二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* cur,vector<int>& vec){
        //终止条件
        if(cur==NULL) return;
        //单层
        traversal(cur->left,vec);
        vec.push_back(cur->val);//中
        traversal(cur->right,vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;
    }
};

114.二叉树展开为链表

前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode* root) {
        //创建返回结果的二叉树
        vector<TreeNode*> l;
        preorderTraversal(root,l);
        int n=l.size();
        //构建返回值的二叉树
        for(int i=1;i<n;i++){
            TreeNode *cur = l.at(i);
            TreeNode *prev = l.at(i-1);
            prev->left = NULL;
            prev->right = cur;
        }

    }

    void preorderTraversal(TreeNode* root,vector<TreeNode*> &l){
        if(root==nullptr) return;
        l.push_back(root);
        preorderTraversal(root->left,l);
        preorderTraversal(root->right,l);
        
    }
};

394.字符串解码

class Solution {
public:
//按引用传递，会在原来的数值上改变
    string getDigits(string &s,size_t &ptr){
        string ret ="";
        //数字直接入栈；
        while(isdigit(s[ptr])){
            ret.push_back(s[ptr++]);//然后指向下一个字符
        }
        //将数字返回
        return ret;
    }

    string getString(vector <string> &v){
        string ret;//拼接
        for(const auto &s:v){
            ret +=s;
        }
        return ret;
    }

    string decodeString(string s) {
//用来解析的栈
    vector<string> stk;
    size_t ptr =0;//数组下标

    while(ptr<s.size()){
        char cur = s[ptr];
    //isdigit 检查是否为数字字符
    if(isdigit(cur)){
        //获取一个数字进栈
        string digits = getDigits(s,ptr);
        stk.push_back(digits);//将数字整体加入
    }else if(isalpha(cur)||cur =='['){
        //获取一个字母并且入栈
        stk.push_back(string(1,s[ptr++]));
    }else{
        //如果当前的字符为右括号，开始出栈，直到左括号出栈
        //2[a2[bc]]
        //拼接字符串
        ++ptr;//跳过]，指向下一个]//指向空
        vector<string> sub;
        while(stk.back()!='['){
            sub.push_back(stk.back());
            stk.pop_back();
        }
        //cb//cbcba
        reverse(sub.begin(),sub.end());
        //bc//abcbc
        stk.pop_back();//左括号出栈
        //此时栈顶应为sub对应出现的次数
        int reptime = stoi(stk.back());
        stk.pop_back();
        string t,o = getString(sub);//拼接单个字符串
        //构造多个字符串
        while(reptime--) t+=o;
        //将构造好的字符串入栈bcbc入栈
        stk.push_back(t);
    }
    }
        return getString(stk);
    }

};