Java中关于String字符串五种常见的算法题目

Posted 2023-01-06 IT-熊猫

1. 模拟一个trim方法，去除字符串两端的空格。

      /*
        1. 模拟一个trim方法，去除字符串两端的空格。
     */
    @Test
    public void test1()
        String s1 = " abc ";
//        System.out.println(s1);
        int start = s1.indexOf(" ");
        int end = s1.lastIndexOf(" ");
        String s2 = s1.substring(start+1,end);
        System.out.println(s2);
    

2. 将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反 转为”abfedcg”

/*
        2. 将一个字符串进行反转。
        将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”
     */
    @Test
    public void test2()
        String s1 = "abcdefg";
        String reverse = this.reverse(s1, 2, 5);
        System.out.println(reverse);
 
 
    
 
    //字符串指定字符反转，返回翻转后的字符串
    public String reverse(String str,int startIndex,int endIndex)
        char[] c1 = str.toCharArray();
        char temp;
        for (int i = startIndex,j = endIndex; i < endIndex ; i++,j--) 
            temp = c1[i];
            c1[i] = c1[j];
            c1[j] = temp;
        
        return new String(c1);
    

3. 获取一个字符串在另一个字符串中出现的次数。 比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

   /*
    3. 获取一个字符串在另一个字符串中出现的次数。
比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数
     */
    @Test
    public void test3()
        String s1 = "abkkcadkabkebfkabkskab";
        String s2 = "abababababababababababab";
        int num1 = times(s2, "ab");
        System.out.println(num1);
 
    
    // 获取一个字符串在另一个字符串中出现的次数。
    public int times(String str1,String str2) 
        int maxLen = str1.length();
        int minLen = str2.length();
        int index = 0;
        int count = 0;
        if (minLen < maxLen)
            while( (index = str1.indexOf(str2,index)) != -1)
                count++;
                index += minLen;
            
        
        return count;
    

4.获取两个字符串中最大相同子串。

 /*
    4.获取两个字符串中最大相同子串。比如：
str1 = "abcwerthelloyuiodef“;str2 = "cvhellobnm"
提示：将短的那个串进行长度依次递减的子串与较长的串比较。
     */
    @Test
    public void test4()
        String str1 = "asdfgrgcihellonasdfj";
        String str2 = "hello";
        String str3 = getMaxSameString(str1,str2);
        System.out.println(str3);
    
    public String getMaxSameString(String str1,String str2) 
 
        //利用三目运算判断出字符串的长短
        String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
        String minStr = (str1.length() < str2.length()) ? str1 : str2;
 
        int minlength = minStr.length();//得到短字符串的长度
        for (int i = 0; i < minlength; i++) 
 
            for (int x = 0, y = minlength - i; y <= minlength; x++, y++) //保证循环中截取的字符串长度一样
                String subStr = minStr.substring(x, y);//截取字符串长度
                if (maxStr.contains(subStr)) //判断是否包含此字符串
                    return subStr;
                
            
 
        
        return null;
    

5.对字符串中字符进行自然顺序排序。

 @Test
    public void test5()
        String s1 = "wersdfgaeragsdgv";
        char[] c1 = s1.toCharArray();
        Arrays.sort(c1);
        String s2 = new String(c1);
        System.out.println(s2);
 
    

6.求一个字符串的所有排列

public class PermutationStr 
    private static void swap(char[] str,int i,int j)
        char tmp = str[i];
        str[i] = str[j];
        str[j] = tmp;
    

    public static void permutation(char[] str,int start)
        if(str == null || start < 0)
            return;
        
        //完成全排列后输出当前排列的字符串
        if(start == str.length -1)
            System.out.println(str);
        else 
            for(int i = start; i < str.length; i++)
                //交换start与i所在位置字符
                swap(str,start,i);
                //固定第一个字符，对剩余的字符串进行全排列
                permutation(str,start+1);
                //还原start与i所在位置的字符
                swap(str,start,i);
            
        
    
    public static void permutation(String s)
        char[] str = s.toCharArray();
        permutation(str,0);
    

    public static void main(String[] args) 
        String s = "abc";
        permutation(s);
    

7.判断一个字符串是否包含重复字符

public class DupStr 
    public static boolean isDup(String str)
        int len = str.length();
        //只需要8个32位的int,8*32位=256位
        int[] flags = new int[8];
        int i;
        for(i = 0; i < 8; i++)
            flags[i] = 0;
        
        for(i = 0; i < len; i++)
            int index = (int)str.charAt(i)/32;
            int shift = (int)str.charAt(i)%32;
            if((flags[index] & (1 << shift)) != 0)
                return true;
            
            flags[index] |= (1 << shift);
        
        return false;
    

    public static boolean isDup1(String str)
        int len = str.length();
        int i,j;
        for(i = 0; i < len; i++)
            for(j = i + 1; j < len; j++)
                if(str.charAt(j) == str.charAt(i))
                    return true;
                
            
        
        return false;
    

8.如何判断两个字符串是否为换位字符串

换位字符串：指组成字符串的字符相同，但位置不同，如：“aaabbbccc”与“abcabcabc”

public static boolean compare(String s1,String s2)
        boolean result = true;
        //假设字符串只使用ASCII字符，共有256个（对应编码0—255）
        int[] count = new int[256];
        int i;
        for(i = 0; i < 256; i++)
            count[i] = 0;
        
        for(i = 0; i < s1.length(); i++)
            count[s1.charAt(i) - '0']++;
        
        for(i = 0; i < s2.length(); i++)
            count[s2.charAt(i) - '0']--;
        
        for(i = 0; i < 256; i++)
            if(count[i] != 0)
                result = false;
                break;
            
        
        return result;