剑指offer-java(3)

输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

import java.util.*;
public class Solution{
    public ArrayList<ArrayList<Integer>> findContinuousSequence(int sum){
        ArrayList<ArrayList<Integer>> listsum=new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(sum<3)return listsum;
        int start=1;
        int end=2;
        int mid=(1+sum)/2;
        int tmp=start+end;
        list.add(start);
        list.add(end);
        while(start<mid){
            if(tmp==sum){
                listsum.add(new ArrayList<Integer>(list));
                end++;
                tmp+=end;
                list.add(end);
            }else if(tmp<sum){
                end++;
                tmp+=end;
                list.add(end);
            }else{
                tmp-=start;
                list.remove(new Integer(start));
                start++;
            }
        }
        return listsum;
    }
}

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

import java.util.*;
public class Solution{
        public ArrayList<Integer> FindNumbers(int[] array,int sum){
    ArrayList<ArrayList<Integer>> listsum=new ArrayList<ArrayList<Integer>>();
    for(int i=0;i<array.length;i++){
        ArrayList<Integer> list=new ArrayList<Integer>();
        for(int j=i+1;j<array.length;j++){
            if(array[i]+array[j]==sum){
                list.add(array[i]);
                list.add(array[j]);
                list.add(array[i]*array[j]);
            }
        }
        if(!list.isEmpty())
            listsum.add(new ArrayList<Integer>(list));
    }
    if(listsum.size()==0)
        return new ArrayList<Integer>();
    Collections.sort(listsum,new Comparator<ArrayList<Integer>>(){
        public int compare(ArrayList<Integer> o1,ArrayList<Integer> o2){
            return o1.get(2).compareTo(o2.get(2));  
        }
    });
    ArrayList<Integer> temp=listsum.get(0);
    ArrayList<Integer> lis=new ArrayList<Integer>();
    for(int i=0;i<temp.size()-1;i++){
        lis.add(temp.get(i));
    }
    return lis;
}
}

对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。

import java.util.*:
public class Solution{
    public String leftRotateString(String str, int n){
        if(str.length()==0)
            return str;
        StringBuffer sb1=new StringBuffer(str);
        StringBuffer sb2=new StringBuffer(str);
        StringBuffer sb=new StringBuffer();
        sb1.delete(0,n);
        sb2.delete(n,str.length());
        return sb.append(sb1.toString()).append(sb2.toString());
    }
}

“student. a am I”。顺序翻转了“I am a student.

import java.util.*;
public class Solution{
    public String ReverseString(String str){
        if(str==null||str.length()==0)
            return str;
        if(str.trim().equals("")){
            return str; 
        }
        String[] s=str.split(" ");
        StringBuffer sb=new StringBuffer();
        for(int i=s.length-1;i>=0;i--){
            sb.append(s[i]).append(" ");
        }
        return sb.toString().trim();
        //sb.toString().substring(0,sb.length()-1);
        //sb.substring(0,sb.length()-1);
    }
}

大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),

import java.util.*;
public class Solution{
    public boolean isContinuous(int[] numbers){
        if(numbers==null||numbers.length==0||numbers.length>5)
            return false;
        ArrayList<Integer> list=new ArrayList<Integer>();
        int len=numbers.length;
        int count=0;
        for(int i=0;i<len;i++){
            if(numbers[i]==0)
                count++;
            else
                list.add(numbers[i]);
        }
        Collections.sort(list);
        int len1=list.size();
        if(Math.abs(list.get(0)-list.get(len1-1))>4)
            return false;
        for(int i=0;i<len1-1;i++){
            int temp=list.get(i+1)-list.get(i);
            if(temp>0&&temp<5)
                continue;
            else
                return false;

        }
        return true;
    }
}

画圈中最后剩下的数
,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数….这样下去….直到剩下最后一个小朋友,

public class Solution{
    public int LastRemaining(int n,int m){
        if(n==0)
            return -1;
        int s=0;
        for(int i=2;i<=n;i++){
            s=(s+m)%i;
        }
        return s;
    }
}

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

//和为n(n+1)/2,除以2可以使用右移来表示
public class Solution{
    public int sum(int n){
        int sum=(int)(Math.pow(n,2)+n);
        return sum>>1;
    }
}

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

import java.math.BigInteger;
public class Solution{
    public int Add(int num1,int num2){
        BigInteger b1=new BigInteger(String.valueOf(num1));
        BigInteger b2=new BigInteger(String.valueOf(num2));
        return b1.add(b2).intValue();
    }
}

字符串转换成一个整数，要求不能使用字符串转换整数的库函数。

public class Solution{
    public int StrToInt(String str){
//需考虑是否为空，有正负号等情况，鲁棒性。      if(str==null||str.length()==0)
            return 0;
        char[] a=str.toCharArray();
        int sum=0;
        int fuhao=0;
        if(a[0]=='-')
            fuhao=1;
        for(int i=fuhao;i<a.length;i++){
            if(a[i]=='+')
                continue;
            if(a[i]<'9'||a[i]>'0')
                return 0;
            sum=sum*10+a[i]-'0';

        }
        return fuhao==0?sum:sum*(-1);
    }
}

数组中重复的数字

public boolean duplicate(int numbers[],int length,int [] duplication) {
        if(numbers==null||length==0)
            return false;
        Arrays.sort(numbers);
        for(int i=0;i<length;i++){
            for(int j=i+1;j<length;j++){
                if(numbers[i]==numbers[j]){
                    duplication[0]=numbers[i];
                    return true;
                }
            }
        }
        return false;
    }

给定一个数组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.*;
public class Solution{
    public int[] multiply(int[] A){
        int len=A.length;
        int[] b=new int[len];
        if(A.length==0)
            return b;
        int[] c=new int[len];
        int[] d=new int[len];

        c[0]=A[0];
        d[len-1]=A[len-1];
        for(int i=1;i<len;i++){
            c[i]=c[i-1]*A[i];
        }

        for(int i=len-2;i>=0;i--){
            d[i]=d[i+1]*A[i];
        }

        b[0]=d[1];
        b[len-1]=c[len-2];
        for(int i=1;i<len-1;i++){
            b[i]=c[i-1]*d[i+1];
        }
        return b;
    }
}

请实现一个函数用来匹配包括’.’和’‘的正则表达式。模式中的字符’.’表示任意一个字符，而’‘表示它前面的字符可以出现任意次（包含0次）

public class Solution{
    public boolean match(char[] str,char[] pattern){
        if(str==null&&pattern==null)
            return true;
        if(str==null||pattern==null)
            return false;
        return match(str,0,str.length,pattern,0,pattern.length);
    }
    private boolean match(char[] str,int i,int length,char[] pattern,int j, int length2){
        if(i==length&&j==length2)//主串和匹配串都匹配结束
            return true;
        if(i!=length && j==length2)//主串没有结束，匹配串结束
            return false;
        if(j+1<length2&&pattern[j+1]=='*'){
            if(i<length&&(str[i]==pattern[j]||pattern[j]=='.')){
        //主串和模式串当前字符匹配
                //主串向后移动，匹配串不变 aaa和a*
                    return match(str,i+1,length,pattern,j,length2)||
//主串向后移动，匹配串跳过  a*  
//主串不变，匹配模式串后2个字符，跳过a*
                match(str,i+1,length,pattern,j+2,length2)||
match(str,i,length,pattern,j+2,length2);
            }else{
                return match(str,i,length,pattern,j+2,length2);
            }
        }
        if(i<length&&(str[i]==pattern[j]||(pattern[j]=='.'))){
            return match(str,i+1,length,pattern,j+1,length2);//主串当前字符不为空，匹配或者匹配串为'.'
        }
        return false;
    }
}

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。

public class Solution{
    public boolean isNumeric(char[] str){
        String s=String.valueOf(str);
        return s.matches("[\\+\\-]?[0-9]*(\\.[0-9]*)?([eE][\\+\\-]?[0-9]+)?");
    //  \为转义字符  + 表示出现至少一次 * 为出现0或多次 ?表示0或1 [  ]括号中的数选择出现
        //( )括号内的元素均要出现
    }
}

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

import java.util.*;
public class Solution{
    Map<Character,Integer> map=new HashMap<>();
    ArrayList<Character> list=new ArrayList<>();
    public void insert(char ch){
        if(map.containsKey(ch)){
            map.put(ch,map.get(ch)+1);
        }else
            map.put(ch,1);
        list.add(ch);
    }
    public char FirstAppear(){
        char ch="#";
        for(char key: list){
            if(map.get(key)==1){
                ch=key;
                break;
            }   
        }
        return ch;
    }
}

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

public class Solution{
    public ListNode EntryNodeOfLoop(ListNode pHead){
        if(pHead==null||pHead.next==null)
            return null;
        ListNode p1=pHead;
        ListNode p2=pHead;
//是否存在环或者找到环的入口，均采用‘快慢指针’的办法
        while(p1!=null&&p2.next!=null){
            p1=p1.next;
            p2=p2.next.next;
            if(p2==null)return null;
            if(p1==p2)
                break;
        }
        p1=pHead;
        while(p1!=p2){
            p1=p1.next;
            p2=p2.next; 
        }
        return p1;
    }
}

链表1->2->3->3->4->4->5 处理后为 1->2->5

public class Solution{
    public ListNode deleteDuplicate(ListNode pHead){
        if(pHead==null)
            return pHead;
        ListNode newHead=new ListNode(0);
        newHead.next=pHead;
        ListNode pre=newHead;
        ListNode cur=pHead;
        while(cur!=null){
            while(cur.next!=null&&cur.val==cur.next.val){
                cur=cur.next;   
            }
            if(pre.next==cur)
                pre=pre.next;
            else
                pre.next=cur.next;
            cur=cur.next;
        }
        return newHead.next;
    }
}

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

public class Solution{
    public TreeLinkNode getNext(TreeLinkNode pNode){
        if(pNode==null)
            return null;
        if(pNode.right!=null){
            //有右子树，则找右子树的最左节点
            pNode=pNode.right;
            while(pNode.left!=null)
                pNode=pNode.left;
            return pNode;
        }else{
//没有右子树，则找第一个当前节点是父节点的左子树的节点    
            while(pNode.next!=null){
                if(pNode.next.left==pNode){
                    return pNode.next;
            }
            pNode=pNode.next;//一直向上找
            }
        }
    }
}

对称的二叉树

public class Solution{
    boolean isSymmetrical(TreeNode pRoot){
        if(pRoot==null)
            return null;
        return isSymmetrical(pRoot.left,pRoot.right);
    }
    private boolean isSymmetrical(TreeNode pleft,TreeNode pright){
        if(pleft==null&&pright==null)
            return true;
        if(pleft==null||pright==null)
            return false;
        if(pleft.val==pright.val)
            return isSymmetrical(pleft.left,pright.right)&&isSymmetrical(pleft.right,pright.left);
        return false;
    }
}

按之字形顺序打印二叉树

public class Solution{
    public ArrayList<ArrayList<Integer>> print(TreeNode pRoot){
        ArrayList<ArrayList<Integer>>  result=new ArrayList<ArrayList<Integer>>();
        if(pRoot==null)
            return result;
        ArrayList<Integer> list=null;
        TreeNode node=null;
        LinkedList<TreeNode> stack1=new LinkedList<>();
        LinkedList<TreeNode> stack2=new LinkedList<>();
        stack1.add(pRoot);
        while(!stack1.isEmpty()){
            list=new ArrayList<>();
            while(!stack.isEmpty()){
                node=stack1.pop();
//将下一层的节点依次入stack,以便下次实现从右往左打印  

                if(node.left!=null)stack2.push(node.left);
                if(node.right!=null)stack2.push(node.right);
                list.add(node.val);
            }
            result.add(list);
            if(stack2.isEmpty())
                break;
            list=new ArrayList<>();
            while(!stack2.isEmpty()){
                node=stack2.pop();
                if(node.right!=null)stack1.push(node.right);
                if(node.left!=null)stack1.push(node.left);
                list.add(node.val);
            }
            result.add(list);
        }
        return result;      
    }
}

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
//队列LinkedList完成层序遍历，end记录每层节点个数

public class Solution{
    ArrayList<ArrayList<Integer>> print(TreeNode pRoot){
        ArrayList<ArrayList<Integer>> list=new ArrayList<>();
        ArrayList<Integer> lista=new ArrayList<Integer>();
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        if(pRoot==null)
            return list;
        queue.add(pRoot);
        int start=0,end=1;
        while(!queue.isEmpty()){
            TreeNode cur=queue.remove();
            lista.add(cur.val);
            start++;
            if(cur.left!=null)
                queue.add(cur.left);
            if(cur.right!=null)
                queue.add(cur.right);
            if(start==end){
                end=queue.size();
                start=0;
                list.add(lista);
                lista=new ArrayList<Integer>();
            }
        }
        return list;
    }
}