3【每天刷力扣（LeetCode）代码详细讲解-括号内字符串翻转

本文章是力扣 (LeetCode)的内容，该专栏还有很多每日刷题的内容等待你去探索，期待你的到来-----欢迎关注订阅！！！

题目描述

给出一个字符串 s（仅含有小写英文字母和括号）。

请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。

注意，您的结果中 不应 包含任何括号。

示例 1：

输入：s = “(abcd)”
输出：“dcba”
示例 2：

输入：s = “(u(love)i)”
输出：“iloveu”
示例 3：

输入：s = “(ed(et(oc))el)”
输出：“leetcode”
示例 4：

输入：s = “a(bcdefghijkl(mno)p)q”
输出：“apmnolkjihgfedcbq”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses

思路讲解+代码展示

1.常规思路（暴力解法）

由于左右括号是对应的 有左括号必定会有一个右括号与之对应，因此，可以利用这一个性质来对本题目进行解析

简单来思考，例如这样的题目：（（ab（cdef（g）h）ij）k）有左就有右，左括号可以从前面找，右括号可以从后面找，这样这个题目就简简单单完成了，然而并不是
如果题目是这样的呢 : （a（bc）（def）g） 这样如果使用上面的思路，那么找到了左右括号就不是对应的，就会出现错误

来换一种找对应括号的思路。
第一步：先找到第一个右括号，那么与之对应的左括号必定就在这个右括号的前面
第二步：反转括号里面的内容，并删除找到的括号
第三步：重复一二步，直到字符串中没有括号为止

就拿上面的例子来说（第一步）
（（ab（cdef（g）h）ij）k）
（a（bc）（def）g）
实践证明这种思路是正确的，那么就可以用这样的思路来对本题目进行代码编写

常规思路（暴力解法）代码展示

void delete_i(char* s, int n)
{
    for (int i = n; i <= strlen(s); i++)
    {
        s[i] = s[i + 1];
    }
}
char* reverseParentheses(char* s)
{
    if(strlen(s) < 2)
    {
        return s;
    }
    int tail = 0;
    int head = 0;
    while (tail <= strlen(s))
    {
        tail = 0;
        head = 0;
        while (s[tail] != ')' && tail < strlen(s))
        {
            tail++;
        }
        if (tail == strlen(s))
        {
            break;
        }
        head = tail - 1;
        while (s[head] != '(' && head >= 0)
        {
            head--;
        }
        int x = head + 1;
        int y = tail - 1;
        char tmp = 0;
        while (x <= y)
        {
            tmp = s[y];
            s[y] = s[x];
            s[x] = tmp;
            x++;
            y--;
        }
        delete_i(s, tail);
        delete_i(s, head);
    }
    return s;
}

2.使用栈+字符串

题目给出的字符串大小	n
栈大小	n
字符串大小	n +1

每次入栈进去的都是一个字符串

思路：
1.开始将给出的字符串（s）中的字符依次往需要返回的字符串（str）中入，
2.当遇到左括号的时候，将字符串往栈（stk）中复制，并将字符串清空，之后继续将往str中入字符
3.当遇到右括号的时候，
第一步，将字符串中的字符翻转，
第二步，将str中的字符整体往后移动，移动的长度就是栈中stk[top-1]字符串的长度
第三步，将stk[top-1]中的字符串从str[0]开始依次赋值
4.直到字符串s遍历完成结束

说这麽多可能不太理解，直接上图

1. (abcd)
开始遍历：
遇到 ‘(’ 将str复制到栈中，并将str清空

入栈完成，继续遍历字符串s

当遇到右括号，1.将str反转 2.将str向后移动，长度为stk[top-1]中字符串的长度 3.将stk[top-1]的内容从str[0]依次赋值

遍历完成，返回str

2. (u(love)i)
开始遍历：
遇到 ‘(’ 将str复制到栈中，并将str清空

入栈完成，继续遍历字符串s

遇到 ‘(’ 将str复制到栈中，并将str清空

入栈完成，继续遍历字符串s

当遇到右括号，1.将str反转 2.将str向后移动，长度为stk[top-1]中字符串的长度 3.将stk[top-1]的内容从str[0]依次赋值

继续遍历

当遇到右括号，1.将str反转 2.将str向后移动，长度为stk[top-1]中字符串的长度 3.将stk[top-1]的内容从str[0]依次赋值

遍历结束，返回str

使用栈+字符串 代码展示

void reverse(char* str, int strSize) //字符串翻转函数
{
    for (int j = 0; j < strSize / 2; j++) 
    {
        char tmp = str[j];
        str[j] = str[strSize - j - 1], str[strSize - j - 1] = tmp;
    }
}

char* reverseParentheses(char* s) 
{
    int n = strlen(s);
    char* stk[n];//栈（相当于二维指针）
    int top = 0;
    char* str = malloc(sizeof(char) * (n + 1));//需要返回的字符串
    str[0] = '\0';
    int strSize = 0;//字符串长度
    for (int i = 0; i < n; i++)//遍历字符串s 
    {
        if (s[i] == '(') //遇到 '(' 将str复制到栈中，并将str清空
        {
            stk[top] = malloc(sizeof(char) * (strSize + 1));
            memcpy(stk[top], str, sizeof(char) * (strSize + 1));
            top++;
            str[0] = '\0';
            strSize = 0;
        } 
        else if (s[i] == ')') 
        //当遇到右括号，1.将str反转 2.将str向后移动，长度为stk[top-1]中字符串的长度 3.将stk[top-1]的内容从str[0]依次赋值
        {
            reverse(str, strSize);//将str反转
            int len = strlen(stk[top - 1]);
            for (int j = strSize; j >= 0; j--) //2.将str向后移动，
            {
                str[j + len] = str[j];
            
            }
            memcpy(str, stk[top - 1], sizeof(char) * len);//将stk[top-1]的内容从str[0]依次赋值
            strSize += len;
            top--;
        } 
        else 
        {
            str[strSize++] = s[i];
            str[strSize] = '\0';
        }
    }
    return str;
}

题目结束

欢迎指点，互相学习