剑指offer 第十一天

46.扑克牌顺子

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

import java.util.Arrays;

public class Solution {

    public boolean isContinuous(int [] numbers) {

        if(numbers.length < 5) return false;

        Arrays.sort(numbers);

        int zerosNum = 0;

        int needZeros = 0;

        for(int i = 0 ;i < 5;i++){

            if(numbers[i] == 0){

                zerosNum++;

            }else if(i+1<5){

                //如存在两数字相同，则一定不是顺子

                if(numbers[i+1] == numbers[i]) return false;

                needZeros += numbers[i+1] - numbers[i] -1;

            }

        }

        //此时大王个数超过四个，不符合题目要求

        if(zerosNum > 4) return false;

        if(zerosNum >= needZeros) return true;

        else return false;

    }

}

46.孩子们的游戏

n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。（约瑟夫环问题）

解法一：使用数组模拟环

public class Solution {

    public int LastRemaining_Solution(int n, int m) {

        if(n<0||m<1) return -1;

        int[] array = new int[n];

        int count=n,step=0,idx=-1;

        while(count>0){

            idx++;

            if(idx == n) idx=0;

            if(array[idx] == -1) continue;//如果是被标记过的则跳过

            step++;

            if(step == m){

                array[idx] = -1;

                count--;

                step=0;

            }

        }

        return idx;

    }

}

解法二：使用ArrayList模拟环

import java.util.ArrayList;

public class Solution {

    public int LastRemaining_Solution(int n, int m){

        if(n<0||m<1) return -1;

        ArrayList<Integer> list = new ArrayList<>();

        for(int i = 0;i<n;i++)

            list.add(i);

        int idx = (m-1)%n;

        while(list.size()>1){

            list.remove(idx);

            idx = (idx+m-1)%list.size();

        }

        return list.get(0);

    }

}

47.求1+2+3+...+n

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

解题思路：(短路求值)

需利用逻辑与的短路特性实现递归终止。
当n==0时，(n>0)&&((sum+=Sum_Solution(n-1))>0)只执行前面的判断，为false，然后直接返回0；
当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)。

public class Solution {

    public int Sum_Solution(int n) {

        int sum = n;

        boolean isEnd = (sum != 0)&&((sum += Sum_Solution(n-1))>0);

        return sum;

    }

}

48.不用加减乘除做加法

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

解析：按位运算

step1:按位与是查看两个数哪些二进制位都为1，这些都是进位位，结果需左移一位，表示进位后的结果
step2:异或是查看两个数哪些二进制位只有一个为1，这些是非进位位，可以直接加、减，结果表示非进位位进行加操作后的结果
step3:n1&n2是查看有没有进位位了，如果有，需要重复step1、step2；如果没有，保留n1、n2上二进制为1的部分，用或将之合为一个数，即为最后结果

public class Solution {

    public int Add(int num1,int num2) {

        int n1,n2;

        n1 = num1 & num2;

        n1 = n1<<1;

        n2 = num1 ^ num2;

        if((n1 & n2) != 0) return Add(n1,n2);

        return n1 | n2;

    }

}

49.把字符串转换成整数

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0

public class Solution {

    public int StrToInt(String str) {

        if(str.length() < 1) return 0;

        char[] nums = str.toCharArray();

        int result = 0;

        int flag = 1;

        for(int i = 0 ; i<nums.length ; i++){

            if(nums[i]-'0'>9 || nums[i]-'0'<0){

                if( i==0 && (nums[i] == '+' || nums[i] == '-'))

                    flag = nums[i] == '+' ? 1 : -1;

                else

                    return 0;

            }else{

                result*=10;

                result+=(nums[i]-'0');

            }

        }

        return result*flag;

    }

}

不适用str.toCharArray()方法

public class Solution {

    public int StrToInt(String str) {

        if(str.length() < 1) return 0;

        int result = 0;

        int flag = 1;

        for(int i = 0 ; i<str.length(); i++){

            if(str.charAt(i)-'0'>9 || str.charAt(i)-'0'<0){

                if( i==0 && (str.charAt(i) == '+' || str.charAt(i) == '-'))

                    flag = str.charAt(i) == '+' ? 1 : -1;

                else

                    return 0;

            }else{

                result*=10;

                result+=(str.charAt(i)-'0');

            }

        }

        return result*flag;

    }

}

50.数组中重复的数字

在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

public class Solution {

    // Parameters:

    //    numbers:     an array of integers

    //    length:      the length of array numbers

    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;

    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++

    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]

    // Return value:       true if the input is valid, and there are some duplications in the array number

    //                     otherwise false

    public boolean duplicate(int numbers[],int length,int [] duplication) {

        if(length<0) return false;

        boolean[] result = new boolean[length];

        for(int i = 0;i<length;i++){

            if(numbers[i]>length-1||numbers[i]<0) return false;

            if(result[numbers[i]]){

                duplication[0] = numbers[i];

                return true;

            }

            result[numbers[i]] = true;

        }

        return false;

    }

}

51.构建乘积数组

给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]A[1]...A[i-1]A[i+1]...A[n-1]。不能使用除法。

import java.util.ArrayList;

public class Solution {

    public int[] multiply(int[] A) {

        int[] B = new int[A.length];

        if(A.length == 0) return B;

        B[0] = 1;

        for(int i = 1;i<A.length;i++){

            B[i] = B[i-1] * A[i-1];

        }

        int temp = 1;

        for(int i = A.length-1;i>=0;i--){

            B[i] *= temp;

            temp *= A[i];

        }

        return B;

    }

}

52.正则表达式匹配

请实现一个函数用来匹配包括'.'和''的正则表达式。模式中的字符'.'表示任意一个字符，而''表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配

解题思路

1.当patternIndex后一位为‘’时：

此时若strIndex == str.length时，直接将patternIndex+2，跳过两个；

如果strIndex!=str.length时，分为以下三种情况：

1.strIndex，patternIndex+2；（str != pattern时）

2.strIndex+1，patternIndex+2；（str = pattern 时或者此时pattern == ‘.’）

3.strIndex+1，patternIndex；(str == pattern 而且 str+1 也 == pattern)

2.当patternIndex后一位不为‘’

此时如果strIndex = str.length return false；

如果 str = pattern 则 str+1，pattern+1

反之 return false；

public class Solution {

    public boolean match(char[] str, char[] pattern)

    {

        //1.边缘检测

        if(str==null||pattern==null) return false;

        int strIndex=0,patternIndex=0;

        return matchCore(str,pattern,strIndex,patternIndex);

    }

    public boolean matchCore(char[] str,char[] pattern,int strIndex,int patternIndex){

        if(strIndex == str.length && patternIndex == pattern.length) return true;

        if(strIndex != str.length && patternIndex == pattern.length) return false;

        //当模式中第二个字符是‘*’

        if(patternIndex+1 < pattern.length && pattern[patternIndex +1] == '*'){

            //一定注意这里strIndex有可能是str.length 需要把str[strIndex]放在后面，以免溢出

            if(strIndex != str.length && (pattern[patternIndex] == '.' || str[strIndex] == pattern[patternIndex])){

                return matchCore(str,pattern,strIndex+1,patternIndex) || matchCore(str,pattern,strIndex+1,patternIndex+2) || matchCore(str,pattern,strIndex,patternIndex+2);

            }else{

                return matchCore(str,pattern,strIndex,patternIndex+2);

            }

        }else{//模式中第二个字符不是’*‘

            if(strIndex != str.length && (str[strIndex] == pattern[patternIndex] || pattern[patternIndex] == '.'))

                return matchCore(str,pattern,strIndex+1,patternIndex+1);

            else

                return false;

        }

    }

}

53.表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

题目分析：数值可以表示为"A+'.'+B+'E/e'+C"

其中A为带符号整数，可以为空
B为不带符号整数，可以为空
A和B不能同时为空
C为带符号整数，不能为空

public class Solution {

    //声明一个全局变量，记录小数点前是否有数字

    boolean hasInt = false;

    public boolean isNumeric(char[] str) {

        if(str == null || str.length == 0) return false;

        return scanA(str,0);

    }

    //第一部分：为带符号整数，后续字符串可包括'./e/E'

    public boolean scanA(char[] str,int index){

        //1.如果有符号则跳过。

        if(str[index] == '-' || str[index] == '+') index++;

        while(index < str.length && str[index]-'0' <= 9 && str[index]-'0' >= 0){

            hasInt = true;

            index++;

        }

        if(index == str.length) return hasInt;

        if(str[index] == '.')

            return scanB(str,index+1);

        else if(str[index] == 'e'||str[index]=='E')

            return scanC(str,index+1);

        else

            return false;

    }

    //第二部分:为不带符号整数,后续字符可带'e/E'

    public boolean scanB(char[] str,int index){

        boolean hasNum = false;

        //用于判断是否是“12.”这种数字

        if(index == str.length) return hasInt || hasNum;

        while(index < str.length && str[index]-'0' <= 9 && str[index]-'0' >= 0){

            index++;

            hasNum = true;

        }

        if(index == str.length) return hasInt || hasNum;

        if(str[index] == 'e' || str[index] == 'E')

            return (hasInt || hasNum) && scanC(str,index+1);

        else

            return false;

    }

    //第三部分：为带符号整数

    public boolean scanC(char[] str,int index){

        //用于判断是否为“12e”这样的数字，这种是不正确的，第三部分不能为空

        if(index == str.length) return false;

        boolean hasNum = false;

        //如果有符号，则跳过

        if(str[index]=='+'||str[index]=='-') index++;

        while(index < str.length && str[index]-'0' <= 9 && str[index]-'0' >= 0){

            hasNum=true;

            index++;

        }

        if(index == str.length) return hasNum;

        else return false;

    }

}

54.字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

输出描述:

如果当前字符流没有存在出现一次的字符，返回#字符。

import java.util.ArrayList;

import java.util.HashSet;

public class Solution {

    ArrayList<Character> list = new ArrayList<>();

    HashSet<Character> set = new HashSet<>();

    //Insert one char from stringstream

    public void Insert(char ch)

    {

        if(!set.contains(ch))

            if(list.contains(ch)){

                //注意这里之所以将char转换为Character对象，是因为，如果直接带入char

                //函数会将char转变成ASCII码int值作为索引，会导致溢出。

                list.remove((Character)ch);

                set.add(ch);

            }else{

                list.add(ch);

            }

    }

  //return the first appearence once char in current stringstream

    public char FirstAppearingOnce()

    {

        if(list.size() > 0)

            return list.get(0);

        else

            return '#';

    }

}

55.链表中的入口结点

一个链表中包含环，请找出该链表的环的入口结点。

方法一：使用辅助Set集合

/*

 public class ListNode {

    int val;

    ListNode next = null;

    ListNode(int val) {

        this.val = val;

    }

}

*/

import java.util.HashSet;

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)

    {

        if(pHead == null) return null;

        HashSet<ListNode> set = new HashSet<>();

        while(!set.contains(pHead)){

            if(pHead.next == null) return null;

            set.add(pHead);

            pHead = pHead.next;

        }

        return pHead;

    }

}

方法二：单纯指针操作

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)

    {

        if(pHead == null) return null;

        ListNode p1=pHead,p2=pHead.next;

        //第一步：如果有环，则算出环的长度；

        while(p1 != p2 && p2 != null){

            p1 = p1.next;

            p2 = p2.next;

            if(p2 == null) return null;

            p2 = p2.next;

        }

        if(p2 == null) return null;

        int count = 1;

        while(p1.next != p2){

            p1 = p1.next;

            count++;

        }

        //第二步：找到环的入口

        p1 = pHead;

        p2 = pHead;

        while(count-- > 0)

            p2 = p2.next;

        while(p1!=p2){

            p1 = p1.next;

            p2 = p2.next;

        }

        return p1;

    }

}

56.删除链表中重复的结点这道题纠结了很久！！！很简单的递归就能实现，有点类似于动态规划

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*

 public class ListNode {

    int val;

    ListNode next = null;

    ListNode(int val) {

        this.val = val;

    }

}

*/

public class Solution {

    public ListNode deleteDuplication(ListNode pHead)

    {

        if(pHead == null || pHead.next == null)

            return pHead;

        if(pHead.val == pHead.next.val){

          while(pHead.next != null && pHead.val == pHead.next.val)

              pHead = pHead.next;

          return deleteDuplication(pHead.next);

        }

        pHead.next = deleteDuplication(pHead.next);

        return pHead;

    }

}

57.二叉树的下一个结点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*

public class TreeLinkNode {

    int val;

    TreeLinkNode left = null;

    TreeLinkNode right = null;

    TreeLinkNode next = null;

    TreeLinkNode(int val) {

        this.val = val;

    }

}

*/

public class Solution {

    public TreeLinkNode GetNext(TreeLinkNode pNode)

    {

        if(pNode == null) return null;

        if(pNode.right != null){

            TreeLinkNode node = pNode.right;

            while(node.left != null)

                node = node.left;

            return node;

        }

        while(pNode.next != null){

            if(pNode.next.right != pNode)

                return pNode.next;

            pNode = pNode.next;

        }

        return null;

    }

}