【精选】JAVA入门算法题（五）

把敬业变成习惯。短期来看是为了雇主，长期来看是为了自己。

1.题目：重复的字符串

/**
 * 给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
 *
 * 输入: "abab"
 * 输出: True
 * 解释: 可由子字符串 "ab" 重复两次构成。
 *
 * 输入: "aba"
 * 输出: False
 */

这道题整体的思路大体有两种，第一种从长度为1开始分割字符串，然后用分割后的字符串去拼接k次，最后比较字符串；第二种其实还是分割字符串，不过是从整体二等分开始，三等分，直到N等分，然后拼接比较。

但要注意的一点是，字符串长度不超过10000,也就是说字符串可能会有7000,8000这么长，你在这里需要加上一个过滤，如果字符串长度对分割长度取余不等于零，那么注定拼接不成目标字符串，应当直接过滤；还有就是注意拼接的方式，最好使用StringBuilder来拼接，因为这种方式比直接字符串拼接效率上有优势。

public static boolean repeatedSubstringPattern(String s) {
        int length=s.length();
        for (int i=1;i<=length/2;i++){
            if (length%i!=0) continue;
            int k=length/i;
            String string=s.substring(0,i);
            StringBuilder a=new StringBuilder();
            for (;k>0;k--){
                a.append(string);
            }
            System.out.println(a);
            if (a.toString().equals(s)){
                return true;
            }
        }
        return false;
    }

2.最小叠加次数

/**
 * 给定两个字符串 A 和 B, 寻找重复叠加字符串A的最小次数，使得字符串B成为叠加后的字符串A的子串，如果不存在则返回 -1。
 * 举个例子，A = "abcd"，B = "cdabcdab"。
 * 答案为 3， 因为 A 重复叠加三遍后为 “abcdabcdabcd”，此时 B 是其子串；A 重复叠加两遍后为"abcdabcd"，B 并不是其子串。
 */

如果B的长度小于A，那么有三种情况，要么A不用叠加，B就已经是A的子串，要么就加个头或者围，比如A是aaaaaaaaaab,B是ba,要么就是同时加上头和尾，就像题目中给的例子一样

如果B的长度大于A，那么A就要至少叠加两者长度之比的倍数，最多也就是这个倍数加上2

要注意一种情况就是无论A如何叠加，B都不是A的子串，也就是B中有A中没有出现的字符，那么我们可以使用indexOf判断，因为要么A长度大于B，就判断B是不是三个A加起来的子串，要么B长度大于A，判断A是不是三个B加起来的子串

public static int repeatedStringMatch(String A, String B) {
        if ((B+B+B).indexOf(A)==-1&&(A+A+A).indexOf(B)==-1){
            return -1;
        }
        int lengthA=A.length();
        int lengthB=B.length();

        int multiple=lengthB/lengthA;
        for (int i=multiple;i<multiple+3;i++){
            StringBuilder stringBuilder=new StringBuilder();
            for (int j=0;j<i;j++){
                stringBuilder.append(A);
            }
            if (stringBuilder.toString().indexOf(B)!=-1){
                return i;
            }
        }
        return -1;
    }

还有一种思路便是将两者的字符循环添加到hashset中，然后进行比较看看是否可达成条件，这样写的代码虽然代码多一些但是效率会高不少，因为字符串拼接很耗时而且indexOf的内部实现也是for循环做的

public static int repeatedStringMatch(String A, String B) {
        if (A.indexOf(B)!=-1){
            return -1;
        }
        int lengthA=A.length();
        int lengthB=B.length();
        String newB=B.replaceAll(A,"");
        HashSet<String> hashSet=new HashSet<String>();
        for (int i=0;i<lengthA;i++){
            hashSet.add(A.substring(i,i+1));
        }
        HashSet<String> hashSet2=new HashSet<String>();
        for (int i=0;i<lengthB;i++){
            hashSet2.add(B.substring(i,i+1));
        }
        for (String s:hashSet2){
            if (!hashSet.contains(s)){
                return -1;
            }
        }

        int multiple=lengthB/lengthA;
        for (int i=multiple;i<multiple+3;i++){
            StringBuilder stringBuilder=new StringBuilder();
            for (int j=0;j<i;j++){
                stringBuilder.append(A);
            }
            if (stringBuilder.toString().indexOf(B)!=-1){
                return i;
            }
        }
        return -1;
    }

3.幂次方

这是一个系列的问题，给定一个整数，判别它是否是2的幂次方

是不是2的幂次方是最好判断的，因为凡是2的幂次方的数转换成二进制都有一个特点，就是前面一个1，后面跟n个0,

2:10

4:100；

8:1000；

16:10000；

我们只需要知道里面一共有多少个1就行了

需要注意的是负数全不是2的幂次方

public static boolean isPowerOfTwo(int n) {
        if (n<=0) return false;
        int x=Integer.toBinaryString(n).indexOf("1");
        int y=Integer.toBinaryString(n).lastIndexOf("1");
        if (x==y){
            return true;
        }else {
            return false;
        }
    }

更快的版本

    public static boolean isPowerOfTwo(int n) {
        if (n<=0) return false;
        int num=0;
        char[] chars=Integer.toBinaryString(n).toCharArray();
        for (int i=0;i<chars.length;i++){
            if (chars[i]=='1'){
                num++;
            }
        }
        if (num!=1){
            return false;
        }else {
            return true;
        }
    }

/**
 * 给定一个整数，写一个函数来判断它是否是 3 的幂次方。
 * 输入: 27
 * 输出: true
 * 输入: 0
 * 输出: false
 */

判断是不是3的幂次方就不能在二进制上找灵感了，但是3的幂次方对3取余一定等于0，且除以三的结果对3取余也是零

需要注意的一就是小于等于0的数都不是3的次幂，1是任何数的0次方；

 public static boolean isPowerOfThree(int n) {
        if (n<=0) return false;
        if (n==1) return true;
        while (n!=3){
            if (n%3!=0){
                return false;
            }
            n/=3;
        }
        return true;
    }

/**
 * 给定一个整数，写一个函数来判断它是否是 4 的幂次方。
 */

对于4的判断我们可以沿用3的方法，也可以在二进制上发现规律，因为一个数是4的幂次方那它就一定是2的幂次方，从二进制上你会发现除了1,2以外，凡是4的倍数都只有一个1和偶数个0；（但是leetcode上说2不是4的幂次方，我不明白为什么）

public static boolean isPowerOfFour(int num) {
        if (num==1) return true;
        if (num<=3) return false;
        while (num!=4){
            if (num%4!=0){
                return false;
            }
            num/=4;
        }
        return true;
    }

if (num==1) return true;
        if (num<=3) return false;
        int one=0;
        int zero=0;
        char[] chars=Integer.toBinaryString(num).toCharArray();
        for (int i=0;i<chars.length;i++){
            if (chars[i]=='1'){
                one++;
            }
            if (chars[i]=='0'){
                zero++;
            }
        }
        if (one!=1){
            return false;
        }else if (zero%2==0){
            return true;
        }
        return false;

4.回文数

/**
 * 给定一个数，判断是不是一个回文数
 */

这个大家都应该做过，只要比较前一半数是不是和后一半数相等就可以了，下面这种方法用到了java自带的string.toCharArray()

 public static boolean isPalindrome(int x) {
        char[] chars=(x+"").toCharArray();
        for (int i=0;i<chars.length/2 ;i++){
            if (chars[i]!=chars[chars.length-1-i]){
                return false;
            }
        }
        return true;
    }

 如果我们不借助这个方法该如何做呢？回文数就是后面等于前面嘛，我们把后边拿出来和前面比一比就可以了，奇数位数的话就把最后一位除10抹掉。我们还可以省去求数字长度的步骤，因为不断取后边的数字拼接，这个也在不断减小，如果拼接的数大于等于这个数的时候就可以停止了。在开始还可以略去两种情况，负数肯定不是回文数，大于0的是10的倍数的数肯定不是回文数

    public boolean isPalindrome(int x) {
        if(x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }
        int revertedNumber = 0;
        while(x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
        return x == revertedNumber || x == revertedNumber/10;
    }

这样就可以了，我们做算法题的时候一定要把注意力放到算法思想上，这样才能学到更多

/**
 * 给定一个链表，判断是不是一个回文链表
 * 输入: 1->2
 * 输出: false
 * 输入: 1->2->2->1
 * 输出: true
 */

public class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

现在整数换成了链表，如何证明这个链表是不是一个回文链表呢？

我们可以先遍历这个链表，把其中的每个数添加到列表里，然后像判断回文数一样判断这个列表

当然，我们还可以借用数据结构的力量，要把一串信息倒过来用栈来做非常合适，我们定义两个变量保存链表的初始状态，也有人叫它们快慢指针，思想都一样，使用一个遍历链表并添加到栈中，然后遍历另一个链表并与栈中pop（）出来的节点进行比对，全一样那就说明这个链表调过来和原链表相同，是个回文链表，有一个不是就不是回文链表；

        Stack<ListNode> stack=new Stack<>();
        ListNode slow=head;
        ListNode fast=head;

        if(fast==null||fast.next==null)//0个节点或是1个节点
            return true;

        stack.push(slow);
        while(fast.next!=null&&fast.next.next!=null)
        {

            fast=fast.next.next;
            slow=slow.next;
            stack.push(slow);
        }
        if(fast.next!=null)//链表长度为偶数
            slow=slow.next;

        ListNode cur=slow;
        while(cur!=null)
        {
            if(cur.val!=stack.pop().val)
                return false;
            cur=cur.next;
        }
        return true;