反转字符串/字符串配对

反转字串：

递归方法：

package cn.itcast.annotation.demo;

public class Reverse {
    public static String reverse(String str){
        if(str.length()<=1)
            return str;
        StringBuffer str1=new StringBuffer();
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i)=='('){
                int j=i;
                int count=0;
                for(;j<str.length();j++){
                    if(str.charAt(j)=='(')
                        count++;

                    if(str.charAt(j)==')')
                        count--;

                    if(count==0)
                        break;
                }
                StringBuffer tmp =new StringBuffer(reverse(str.substring(i+1,j)));
                for (int i1 =  tmp.length()-1; i1>=0; i1--) {
                    str1.append(tmp.charAt(i1));
                }
                i=j;
            }
            else{
                str1.append(str.charAt(i));
            }

        }
        return str1.toString();
    }

    public static void main(String[] args) {
        String s="(ed(eb(oc))em)";
        System.out.println(reverse(s));
    }
}

使用栈：

package cn.itcast.annotation.demo;

import java.util.Stack;

class Reverse {
    public static String reverseParentheses(String s) {
        Stack<Integer> stack = new Stack<>();
        StringBuilder res = new StringBuilder();
        char[] chs = s.toCharArray();

        for (int i = 0; i < chs.length; i++) {
            if (chs[i] == '(') {
                stack.push(i);
            } else if (chs[i] == ')') {
                reverse(chs, stack.pop() + 1, i - 1);
            }
        }
        for (char ch : chs) {
            if (ch != '(' && ch != ')') {
                res.append(ch);
            }
        }
        return res.toString();
    }

    private static void reverse(char[] chs, int start, int end) {
        while (end > start) {
            char temp = chs[end];
            chs[end] = chs[start];
            chs[start] = temp;
            start++;
            end--;
        }
    }
    public static void main(String[] args) {
        String s="(ed(eb(oc))em)";
        System.out.println(reverseParentheses(s));
    }
}

class Solution {
    public String reverseParentheses(String s) {
        int n = s.length();
        Stack<Integer> stack = new Stack<>();
        int[] pair = new int[n];

        //先去找匹配的括号
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '(') {
                stack.push(i);
            } else if (s.charAt(i) == ')') {
                int j = stack.pop();
                pair[i] = j;
                pair[j] = i;
            }
        }

        StringBuilder res = new StringBuilder();
        // i是当前位置 | d是方向,1就是向右穿
        for (int i = 0, d = 1; i < n; i+=d) {
            if (s.charAt(i) == '(' || s.charAt(i) == ')') {
                // 如果碰到括号，那么去他对应的括号，并且将方向置反
                i = pair[i];
                d = -d;
            } else {
                res.append(s.charAt(i));
            }
        }
        return res.toString();
    }
}

 
链接：https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses/solution/chong-dong-fa-yi-ge-zhi-zhen-de-qi-huan-piao-liu-b/
 

字符串反转：

可以利用数据结构中的栈，因为栈的特点是先入后出（这里可以提一下和队列的不同，队列的特点是先入先出），先把字符串中的每个字符按顺序入栈，再依次出栈，即可实现字符串的反转。

    String str = "leetcode";

    char[] charArray = str.toCharArray();
    Stack<Character> stack = new Stack<>();
    StringBuilder newStr = new StringBuilder();

    for (char item : charArray) {
        stack.push(item);
    }

    for (int i = 0; i < charArray.length; i++) {
        newStr.append(stack.pop());
    }

    System.out.println("反转前：" + str);
    System.out.println("反转后：" +newStr.toString());

字符串配对问题

括号配对问题
描述
现在，有一行括号序列，请你检查这行括号是否配对。
输入
第一行输入一个数N（0<N<=100）,表示有N组测试数据。后面的N行输入多组输入数据，每组输入数据都是一个字符串S(S的长度小于10000，且S不是空串），测试数据组数少于5组。数据保证S中只含有"[","]","(",")"四种字符
输出
每组输入数据的输出占一行，如果该字符串中所含的括号是配对的，则输出Yes,如果不配对则输出No
样例输入
3
[(])
(])
([])
样例输出
No
No
Yes

import java.util.Scanner;  
import java.util.Stack;  
  
public class Main {  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in);  
        int N = scan.nextInt();  
        String s;  
        for (int i = 0; i < N; i++) {  
            s = scan.next();  
            if (isMatch(s)) {  
                System.out.println("Yes");  
            } else {  
                System.out.println("No");  
            }  
        }  
    }  
    private static boolean isMatch(String s) {  
        Stack<Character> sk = new Stack<Character>();  
        for (int i = 0; i < s.length(); i++) {  
            if (s.charAt(i) == '(') {  
                sk.push('(');  
            }  
            if (s.charAt(i) == ')') {  
                if (!sk.isEmpty() && sk.pop() == '(')  
                    continue;  
                else  
                    return false;  
            }  
            if (s.charAt(i) == '[') {  
                sk.push('[');  
            }  
            if (s.charAt(i) == ']') {  
                if (!sk.isEmpty() && sk.pop() == '[')  
                    continue;  
                else  
                    return false;  
            }  
        }  
        if (sk.isEmpty())  
            return true;  
        else  
            return false;  
    }  
}