LeetCode算法刷题

LeetCode刷题

1190 . 反转每对括号间的子串

题目描述：

给出一个字符串 s（仅含有小写英文字母和括号）。
请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。
LeetCode题链接

题意理解：

1. 给出一串包含多对括号的字符串，“（”和“）”必须是一对一对的出现。
2. 我们需要从内层“（）”将“（）”内的字符串进行反转，然后去掉这对“（）”。

解决思路：

1.把String转换为char数组。

char[] ss = s.toCharArray();

2.将char数组添加到list当中。

List<String> nums = new ArrayList();

3.封装一个反转（）内字符串的方法。

//反转（）内的内容并删除括号
    public static void delete(List<String> nums){
        //查找char里的“（”和“）”一一匹配，如果匹配上就将里面的值反转，并将括号删除
        //去掉的括号

        for (int i = 0; i < nums.size(); i++) {
            if (nums.get(i).equals("(")) {
                for (int j = i + 1; j < nums.size(); j++) {
                    if (nums.get(j).equals("(")) {
                        break;
                    }
                    if (nums.get(j).equals(")") && j > i) {


                        for (int k = 0; k < ((j - i) / 2) + 1; k++) {
                            System.out.println((i + k) + "<=>" + (j - k));

                            Collections.swap(nums, i + k, j - k);

                        }
                        System.out.println("结果1" + nums + "删除了" + i);
                        //删除已经反转过的括号
                        nums.remove(i);
                        System.out.println("结果1" + nums + "删除了" + (j - 1));
                        nums.remove(j - 1);
                        //每次删除括号的String
                        System.out.println("结果2" + nums);
                        break;
                    }
                }
            }
        }

4.list转string。

public static String listToString(List list) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i));
        }
        return sb.toString();
    }

整体代码：

package leecode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static java.lang.String.valueOf;

//1190. 反转每对括号间的子串
//请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。
public class test12 {
    public static void main(String[] args) {
        System.out.println(reverseParentheses("(ed(et(oc))el)"));
    }

    static public String reverseParentheses(String s) {

        //把String转换为char数组
        char[] ss = s.toCharArray();
        //将数组添加到list当中
        List<String> nums = new ArrayList();
        delete(nums);
        for (int k = 0; k < ss.length; k++) {
            nums.add(new String().valueOf(ss[k]));
        }

        for (int i = 0; i < nums.size(); i++) {
            if (nums.get(i).equals("(")) {
                delete(nums);
            }
        }

        return listToString(nums);
    }
    //反转（）内的内容并删除括号
    public static void delete(List<String> nums){
        //查找char里的“（”和“）”一一匹配，如果匹配上就将里面的值反转，并将括号删除
        //去掉的括号

        for (int i = 0; i < nums.size(); i++) {
            if (nums.get(i).equals("(")) {
                for (int j = i + 1; j < nums.size(); j++) {
                    if (nums.get(j).equals("(")) {
                        break;
                    }
                    if (nums.get(j).equals(")") && j > i) {


                        for (int k = 0; k < ((j - i) / 2) + 1; k++) {
                            System.out.println((i + k) + "<=>" + (j - k));

                            Collections.swap(nums, i + k, j - k);

                        }
                        System.out.println("结果1" + nums + "删除了" + i);
                        //删除已经反转过的括号
                        nums.remove(i);
                        System.out.println("结果1" + nums + "删除了" + (j - 1));
                        nums.remove(j - 1);
                        //每次删除括号的String
                        System.out.println("结果2" + nums);
                        break;
                    }
                }
            }
        }
        for (int i = 0; i < nums.size(); i++) {
            if (nums.get(i).equals("(")) {
                delete(nums);
            }
        }
    }
    //list转string
    public static String listToString(List list) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i));
        }
        return sb.toString();
    }
}

输出结果

总结：

本题用到的知识有字符串的匹配，字符串和字符数组之间的相互转换，而解决的逻辑就是，先找到一个“（”，然后判断这个”（“后面还有没有”（“，如果有的话，那么他就不是最内层的，那么循环将继续，直至找到最内层的”（）“。

反转字符串的逻辑就是，找到最内层的”（）“后，将里面的内容进行反转。并删除这对”（）“，保证下次找到最内层的”（）“不受干扰。

循环的建立，每次循环一次，删除”（）“操作之后都要判断list数列当中是否还存在”（）“，如果存在则再次进入循环。