最长公共前缀

题目描述

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 “”。

题点

依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。如果在尚未遍历完所有的字符串时，最长公共前缀已经是空串，则最长公共前缀一定是空串，因此不需要继续遍历剩下的字符串，直接返回空串即可。

代码

public class pra5 {
    public static void main(String[] args) {
        String[] strs;
        strs=new String[]{"abbb","a","accc","aa"
};//"caa","","a","acb"  "c","acc","ccc"  "flower","flow","flight"
        String string=  longestCommonPrefix1(strs);
        System.out.println("The same string is"+string);
    }
        //法1：横向扫描复杂版
    /*1.依次遍历字符串数组中的每个字符串，按序统计字符的公共数，当满足公共数==字符串数组的长度，更新最长公共前缀；
    当公共数！=字符串数组长度，即表示不再有公共字符，并返回 */
    public static String longestCommonPrefix1(String[] strs) {
        String str="";
        if(strs.length==0||strs==null){  //1.判断字符串数组是否为空
            return "";
        }
        int min=strs[0].length(); //假设第一个字符串元素的长度最小
        int flag=0;
        for (int i = 0; i < strs.length; i++) {  //遍历字符串数组
            if(strs[i].length()!=0&&strs[i]!=null){ //若字符串不为空
                if(min>strs[i].length()){ //则对字符串进行长度最小的判断
                    min=strs[i].length();
                    flag=i;
                }
            }else{
                return "";
            }
        }
        for (int i = 0; i < strs[flag].length(); i++) {  //遍历最短字符串的单个字符
            int count=1;
            for (int j = 1; j <strs.length; j++) { //遍历第2个字符串到最后一个字符串
                if(strs[0].charat(i)==strs[j].charat(i)){ //如果第0个字符串的第i个字符==第j字符串的第i个字符，则
                    count++;
                }else{
                    return str; //存在不满足，则返回str
                }
            }
            if(count==strs.length){ //找到公共字符
                str+=strs[0].charat(i); //获获得公共字符
            }
            if(count!=strs.length){//当有一字符不满足公共
                if(str.length()==0){ //判断是否从一开始就不满足
                    str="";
                }else{
                    break;  //跳出循环
                }
            }
        }
        return str;
    }
    //法二：
    /*依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。*/
    public  static  String longestCommonPrefix2(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        String prefix = strs[0];
        int count = strs.length;
        for (int i = 1; i < count; i++) {
            prefix = longestCommonPrefix(prefix, strs[i]);
            if (prefix.length() == 0) {
                break;
            }
        }
        return prefix;
    }
    public  static  String longestCommonPrefix(String str1, String str2) {
        int length = Math.min(str1.length(), str2.length());
        int index = 0;
        while (index < length && str1.charat(index) == str2.charat(index)) {
            index++;
        }
        return str1.substring(0, index);
    }
    //法3：
    public String longestCommonPrefix3(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length = strs[0].length();
        int count = strs.length;
        for (int i = 0; i < length; i++) {
            char c = strs[0].charat(i);
            for (int j = 1; j < count; j++) {
                if (i == strs[j].length() || strs[j].charat(i) != c) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }
}

有效括号

题目描述

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

题点

字符串不能为空
括号得成对存在，因此字符串长度不能是奇数
左括号得和右括号一一对应，即后遇到的左括号要先闭合
确定左括号和对应的右括号

复杂未解决版

排除字符串为空或字符串的长度为奇数
用map集合储括号的类型和数量
进行遍历，将遍历到的括号进行数量++
当对应的括号之和达到偶数，且左括号后存在下标之差为奇数的右括号
但没有解决右括号在左括号之前的问题，eg： (){}}{

官方解答版

字符串的长度为奇数【题目要求字符串不能为空】
用map集合的key存储右括号，value存储对应的左括号【通过哈希表存储括号，并快速判断】
后遇到的左括号要先闭合
对字符串进行遍历，当遇到左括号时放入栈里；当遇到右括号，则取出栈顶的左括号并判断它们是否为相同类型的括号；若不是相同的类型，或栈中没有左括号，则字符串无效，返回false
在遍历结束后，若栈中没有左括号，则说明将字符串中的所有左括号闭合，返回true，否则返回false

代码

public class pra7 {
    public static void main(String[] args) {
        String str="(){}}{";
        // ()     ()[]{}      (]        ([)]        {[]}   (){}}{
        boolean flag=isValid1(str);
        System.out.println("The result is "+flag);
    }
   public static boolean isValid1(String str) {
       boolean flag = false;
       if (str.length() == 0 || str == null || str.length() % 2 != 0) {  //排除字符串为空或字符串的长度为奇数
           flag = false;
       }
       Map<Character, Integer> mapvalue = new HashMap<>();
       mapvalue.put('(', 0);  //存储括号的类型和数量
       mapvalue.put('{', 0);
       mapvalue.put('[', 0);
       mapvalue.put(')', 0);
       mapvalue.put('}', 0);
       mapvalue.put(']', 0);
       int temp = str.length();
       for (int i = 0; i < temp; i++) {
           Character c = str.charat(i);
           if (mapvalue.containsKey(c)) {
               mapvalue.replace(c, mapvalue.get(c) + 1);
               System.out.println(c + "is " + mapvalue.get(c));  // 进行遍历，将遍历到的括号进行数量++
           }
       }
       //当对应的括号之和达到偶数
       if (mapvalue.get('(') == mapvalue.get(')') && mapvalue.get('[') == mapvalue.get(']') && mapvalue.get('{') == mapvalue.get('}')) {
          for (int i = 0; i < temp; i++) {    // (){}}{
               Character c = str.charat(i);
              boolean f1=c=='('&&((str.indexOf(str.valueOf(')'))-i)%2!=0)&&((str.indexOf(str.valueOf(')'))-i)>=0);//检验左括号之后还有右括号，且距离相等，能凑成一对
              boolean f2=c=='{'&&((str.indexOf(str.valueOf('}'))-i)%2!=0)&&((str.indexOf(str.valueOf('}'))-i)>=0);
              boolean  f3=c=='['&&((str.indexOf(str.valueOf(']'))-i)%2!=0)&&((str.indexOf(str.valueOf(']'))-i)>=0);
            /*  boolean f4=c=='}'&&((str.indexOf(str.valueOf('{'))-i)<0);
              boolean f5=c==']'&&((str.indexOf(str.valueOf(']'))-i)<0);
              boolean f6=c==')'&&((str.indexOf(str.valueOf(')'))-i)<0);
*/
              if(f1) flag=true; //
              if(f2) flag=true;
              if(f3) flag=true;
             // if(f4) flag=false;
           }
       }
       return flag;
    }
    public  static boolean isValid(String s){
        int n = s.length(); //获取字符串的长度
        if (n % 2 == 1) { //排除字符串中的括号不成对的情况
            return false;
        }
        Map<Character, Character> pairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Deque<Character> stack = new LinkedList<Character>();  //声明一个栈，
        for (int i = 0; i < n; i++) {
            char ch = s.charat(i); //遍历字符串
            if (pairs.containsKey(ch)) { //判断是否包含右括号
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
                    //peek：查看栈顶部的对象，但不移除
                    return false;
                }
                stack.pop(); //移除栈顶的括号
            } else {
                stack.push(ch);//将括号推送到顶部
            }
        }
        return stack.isEmpty();
    }

}