牛客网 剑指Offer，一些值得记住的小题（五）

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

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) {                for(int i=0;i<length;i++){            int index = numbers[i];            if(index>=length){                index-=length;            }            if(numbers[index]>=length){                duplication[0]=index;                return true;            }            numbers[index] = numbers[index]+length;        }        return false;    }}

解析：本题要利用好题中的条件以减少时间复杂度（"在一个长度为n的数组里的所有数字都在0到n-1的范围内"）首先取出一个数，以这个数作为角标的位置上的数+length，当遇到某个数比数组长度大时就存入duplication[]

26.给定一个数组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];        B[0]=1;        if(A.length!=0){            for(int i=1;i<A.length;i++){            B[i]=B[i-1]*A[i-1];        }        int temp=1;        for(int i=A.length-2;i>=0;i--){            temp*=A[i+1];            B[i]*=temp;        }        }                return B;        /*if(A.length==0){            return null;        }        int [] B = new int [A.length];                for(int i=0;i<B.length;i++){            B[i]=1;            for(int j=0;j<A.length;j++){                if(j==i){                    continue;                }else{                    B[i]*=A[j];                }                            }             }        return B;*/    }}

解析：如下图，为了减少复杂度，思路是先算正方形的左下半部分，再算右上半部分

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

public class Solution {    public boolean match(char[] str, char[] pattern)    {        if(str==null||pattern==null){            return false;        }        int sindex=0;        int pindex=0;        return Match(str,sindex,pattern,pindex);    }    public boolean Match(char[] str,int sindex,char[] pattern,int pindex){        if(sindex==str.length&&pindex==pattern.length){            return true;        }        if(sindex!=str.length&&pindex==pattern.length){            return false;        }        if(pindex+1<pattern.length&&pattern[pindex+1]=='*'){当前要匹配的pattern中的字符的后面是"*"的情况            //如果当前匹配的字符是‘.’或者两个字符相等的情况，就会分为三种情况，sindex后挪，或者pindex后挪，或者dounuo            if((sindex!=str.length&&str[sindex]==pattern[pindex])||(sindex!=str.length&&pattern[pindex]=='.')){                return Match(str,sindex,pattern,pindex+2)||                    Match(str,sindex+1,pattern,pindex+2)||                    Match(str,sindex+1,pattern,pindex);            }            //如果不匹配的话就相当于把'*'用掉了，就直接pindex后挪            else{            return Match(str,sindex,pattern,pindex+2);            }        }        //如果当前正在验证的字符后面不是'*',如果当前字符匹配则都后挪，否则直接返回false        if((sindex!=str.length&&str[sindex]==pattern[pindex])||(str.length!=sindex&&pattern[pindex]=='.')){            return Match(str,sindex+1,pattern,pindex+1);        }        return false;    }}

解析：见代码中的注释。

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

/* public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}*/public class Solution {    public ListNode EntryNodeOfLoop(ListNode pHead)    {        if(pHead==null||pHead.next==null){            return null;        }        ListNode p1=pHead;        ListNode p2=pHead;        int pp1=2;        int pp2=1;        p1=p1.next;        p1=p1.next;        p2=p2.next;        while(p1!=p2){            p1=p1.next;            p1=p1.next;            p2=p2.next;            pp1+=2;            pp2++;        }        int n = pp1-pp2;        p1=pHead;        p2=pHead;        for(int i=0;i<n;i++){            p1=p1.next;        }        while(p1!=p2){            p1=p1.next;            p2=p2.next;        }        return p1;    }}

解析：p1,p2都指向表头，pp1,pp2分别记录两者的步数，p1走两步，p2走一步，当p1,p2相遇时就说明p1,p2都在圈里并且p1已经比p2多走一圈了，这时候pp1-pp2就是一圈的长度，再重新指向表头，这次让p1先走一圈的长度，然后一起一步一步向后走，当到了相同节点是就是要找的节点。

29.请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    boolean isSymmetrical(TreeNode pRoot)    {        if(pRoot==null){            return true;        }        return test(pRoot.left,pRoot.right);    }    boolean test(TreeNode left,TreeNode right){        if(left==null) return right==null;        if(right==null) return false;        if(left.val!=right.val) return false;        return test(left.right,right.left)&&test(left.left,right.right);    }}

解析：利用递归，注意test()中的参数就可以

30.请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

import java.util.ArrayList;import java.util.Stack;/*public class TreeNode {    int val = 0;    TreeNode left = null;    TreeNode right = null;    public TreeNode(int val) {        this.val = val;    }}*/public class Solution {    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {                ArrayList<ArrayList<Integer>> listall=new ArrayList<ArrayList<Integer>>();        if(pRoot==null){            return listall;        }        ArrayList<Integer> list = new ArrayList<Integer>();        Stack<TreeNode> s1 = new Stack<TreeNode>();        Stack<TreeNode> s2 = new Stack<TreeNode>();        int flag=0;//flag=0从左往右输出，从右往左压栈        s1.push(pRoot);        while(s1.size()>0){            TreeNode temp = s1.pop();            list.add(temp.val);            if(flag==1){                if(temp.right!=null){                    s2.push(temp.right);                }                if(temp.left!=null){                    s2.push(temp.left);                }                            }else{                if(temp.left!=null){                    s2.push(temp.left);                }                if(temp.right!=null){                    s2.push(temp.right);                }            }        if(s1.size()==0){            flag=1-flag;            Stack<TreeNode> t = s1;            s1=s2;            s2=t;            //s1=s2;            //s2.clear();            listall.add(new ArrayList<Integer>(list));            list.clear();        }        }        return listall;    }}

解析：其实可以用reverse()，但是还是需要考虑复杂度的问题，所以这个用两个栈就可以解决，先把第一层压栈，因为第二层要从右往左输出，所以要先将左子树后右子树压s2栈，当s1空时，s1=s2,继续将s1中结点的字数压栈，通过flag来标记应该从左往右还是从右往左，以此类推。

31.请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如[a b c e s f c s a d e e]是3*4矩阵，其包含字符串"bcced"的路径，但是矩阵中不包含“abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

public class Solution {    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)    {        int [] flag = new int[matrix.length];        for(int i=0;i<rows;i++){            for(int j=0;j<cols;j++){                if(Test(matrix,rows,cols,i,j,str,0,flag)){                    return true;                }            }        }        return false;    }    //matrix就是题中的[a b c e s f c s a d e e]，rows,cols是行和列，str就是题中的"bcced"，k是str的角标 ,flag用来标记该点走没走过    public boolean Test(char[] matrix,int rows,int cols,int i,int j,char[] str,int k,int[] flag){        int index = i*cols+j;        //如果走过或者值不相等就返回false        if(i<0||i>=rows||j<0||j>=cols||str[k]!=matrix[index]||flag[index]==1){            return false;        }        if(k==str.length-1){            return true;        }        //标记该点已经走完了        flag[index]=1;        //然后检查四周是否有和下个字符匹配的点        if(Test(matrix,rows,cols,i+1,j,str,k+1,flag)||          Test(matrix,rows,cols,i-1,j,str,k+1,flag)||          Test(matrix,rows,cols,i,j+1,str,k+1,flag)||          Test(matrix,rows,cols,i,j-1,str,k+1,flag)){            return true;        }        //递归结束后，要删除这个点，即标记这个点没有到过，是一种回溯思想，以为这个点并不是想要的点        flag[index]=0;        return false;    }}

解析：见代码的注释