首页 > 编程语言> > 每日十道算法

每日十道算法

2022-03-20 10:05:35 作者：互联网

1、整数转换

整数转换。编写一个函数，确定需要改变几个位才能将整数A转成整数B。

class Solution {
    public int convertInteger(int A, int B) {

        //A与B进行异或运算，得到的结果1就是不相同，0就是相同
        //0011^1100 = 1111 结果有几个1，那么就有几个位要改变    
        int n = A ^ B;
        int res = 0;
        while(n != 0){
            //n&(n -1) 可以把n最右边的1置0，其余位不变
            //这样，这个操作执行了几次，就是有几位要转换            
            n = n & (n - 1);
            res++;
        }
        return res;       
    }
}

2、左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。
请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

class Solution {
    public String reverseLeftWords(String s, int n) {
        if(s.length() == 0){
            return "";
        }
        StringBuilder sb = new StringBuilder(s).reverse();
        String s1 = sb.substring(0,sb.length() - n);
        String s2 = sb.substring(sb.length() - n);
        return new StringBuilder(s1).reverse().append(new StringBuilder(s2).reverse()).toString();
    }
}

3、旋转字符串

给定两个字符串, A 和 B。A 的旋转操作就是将 A 最左边的字符移动到最右边。例如, 若 A = 'abcde'，在移动一次之后结果就是'bcdea' 。如果在若干次旋转操作之后，A 能变成B，那么返回True。

时间复杂度：$O(n的平方)
空间复杂度：$O(n)

class Main {
    public boolean main(String A, String B) {
        return A.length() == B.length() && (A + A).contains(B);
    }
}

4、替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

class Solution {
    public String replaceSpace(String s) {
        char[] ch = s.toCharArray();
        StringBuilder s1 = new StringBuilder();
        for(char i : ch){
            if(i == ' '){
                s1.append("%20");
            }else{
                s1.append(i);
            }
            
        }
        return s1.toString();
    }
}

5、重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        String str = s + s;
        return str.substring(1, str.length() - 1).contains(s);
    }
}

6、不含重复字符的最长子字符串

给定一个字符串 s ，请你找出其中不含有重复字符的最长连续子字符串的长度。

class Main {
    public int main(String s) {
        int left = 0;
        int right = 0;
        int res = 0;
        Set<Character> set = new HashSet<>();
        while(left < s.length() && right < s.length()){
            if(set.contains(s.charAt(right))){
                set.remove(s.charAt(left));
                left++;
            }else{
                set.add(s.charAt(right));
                right++;
                res = Math.max(right - left,res);
            }
        }
        return res;
    }
}

7、删除字符串中的所有相邻重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

import java.util.*;
class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for(char c : s.toCharArray()){
            if(stack.isEmpty() || c != stack.peek()){
                stack.push(c);
            }else{
                stack.pop();
            }
        }

        String str = "";
        while(!stack.isEmpty()){
            str = stack.pop() + str;
        }
        return str;

    }
}

8、回文子串

给你一个字符串 s ，请你统计并返回这个字符串中回文子串的数目。
回文字符串是正着读和倒过来读一样的字符串。

子字符串是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被
视作不同的子串。

class Solution {
    public int countSubstrings(String s) {

        int len = s.length();
        if (s == null || len == 0){
            return 0;
        }
        //dp[i][j]：s字符串下标i到下标j的字串是否是一个回文串，即s[i, j]
        boolean[][] dp = new boolean[len][len];
        for (int j = 0; j < len; j++) {
            for (int i = 0; i <= j; i++) {
                //当两端字母一样时，才可以两端收缩进一步判断
                if (s.charAt(i) != s.charAt(j)){
                    dp[i][j] = false;
                }else{
                    //i++，j--，即两端收缩之后i,j指针指向同一个字符或者i超过j了,必然是一个回文串
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        //否则通过收缩之后的字串判断
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }
            }
        }
        //遍历每一个字串，统计回文串个数
        int res = 0;
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len; j++) {
                if (dp[i][j]) {
                    res++;
                }
            }
        }
        return res;
    }
}

9、最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

public class Solution {

    public String longestPalindrome(String s) {
        // 特殊用例判断
        int len = s.length();
        if (len < 2) {
            return s;
        }

        int begin = 0;
        int maxLen = 1;
        // dp[i][j] 表示 s[i, j] 是否是回文串
        boolean[][] dp = new boolean[len][len];
        for (int j = 0; j < len; j++) {
            for (int i = 0; i <= j; i++) {
                if (s.charAt(i) != s.charAt(j)) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][j] == true 成立，就表示子串 s[i..j] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin + maxLen);
    }
}

10、最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。

一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
        for(int i = 1; i <= text1.length(); i++){
            char char1 = text1.charAt(i - 1);
            for(int j = 1; j <= text2.length(); j++){
                char char2 = text2.charAt(j - 1);
                if(char1 == char2){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = Math.max(dp[i - 1][j],dp[i][j - 1]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

标签：return,String,int,每日,算法,十道,字符串,length,public
来源： https://blog.csdn.net/qq_44920726/article/details/123571700