剑指offer java实现

二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

 public boolean Find(int target, int [][] array) {
         boolean found=false;      //从左下角开始
        if(array==null){return found;}
        int i=array.length-1,j=0;
       while(i>=0&&j<=array[0].length-1){
           if(array[i][j]==target){
               return true;
           }else if(array[i][j]<target){
               j++;
           }else{
               i--;
           }
       }
        return found;
    }

 替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

  public String replaceSpace(String str) {
        if(str.length()<=0||str==null) return null;
        int n=0;
    	for(int i=0;i<str.length();i++){
            if(str.charAt(i)==' ') n++;
        }
        char[] arr=new char[str.length()+2*n];
        int k=str.length()+2*n-1;
        for(int i=str.length()-1;i>=0;i--){
            if(str.charAt(i)==' ') {
                arr[k--]='0';
                arr[k--]='2';
                arr[k--]='%';
            }else{
            arr[k--]=str.charAt(i);}
        }
        return new String(arr);
    }

return str.replaceAll(" ","%20");  //一行代码搞定

从尾到头打印链表

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

public class Solution {
    ArrayList<Integer> list=new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    
            if(listNode!=null)
            {this.printListFromTailToHead(listNode.next);
            list.add(listNode.val);
            
        }
        return list;
        
    }

跳台阶

动态规划比递归效率高

   public int JumpFloor(int target) {
          if(target==1||target==0) return 1;
        int n1=1,n2=1,sum=0;
        for(int i=2;i<=target;i++){
            sum=n1+n2;
            n1=n2;
            n2=sum;
        }
        return sum;
    }

变态跳台阶
 

  f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)

    f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)

    可以得出：  f(n) = 2*f(n-1)

public int JumpFloorII(int target) {
        if(target==0||target==1) return 1;
        else return 2*JumpFloorII(target-1);
    }

二进制中1的个数

 public int NumberOf1(int n) {
       int num=0;
        while(n!=0){
            num++;
            n=n&(n-1);
        }
        return num;
    }

数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

public class Solution {
    public double Power(double base, int exponent) {
            if(exponent==0) return 1;
             if(exponent<0) 
               return power(1/base,-exponent);//幂小于零的情况
             return power(base,exponent);
        }
  
    public double power(double base, int exponent){
        if(exponent==0) return 1;
        if(exponent%2==0) {
            return power(base*base,exponent/2);  
            
        }else{
            return base*power(base*base,exponent/2);
        }
    }
}

旋转数组的最小数字

 public int minNumberInRotateArray(int [] array) {
         int l=0;
        int r=array.length-1;
        while(l<r){
            int mid=l+(r-l)/2;
            if(array[mid]>array[r]){
                l=mid+1;
            }else if(array[mid]<array[r]){
                r=mid;
            }else{
                r=r-1;
            }
        }
        return array[l];
    }

调整数组顺序使奇数位于偶数前面

public void reOrderArray(int [] array) {
        int[] a=new int[array.length];
     int[] b=new int[array.length];
     int j=0,k=0;
        for(int i:array){
         if(i%2!=0)
             a[j++]=i;
         else
             b[k++]=i;
     }
     for(int i=0;i<j;i++){
            array[i]=a[i];
     }
     for(int i=0;i<k;i++){
            array[j+i]=b[i];
     }
    }

矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

public int RectCover(int target) {
          if(target<=0) return 0;
        if(target==1||target==2) return target;
        return RectCover(target-1)+RectCover(target-2);
    }

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

链接：https://www.nowcoder.com/questionTerminal/8a19cbe657394eeaac2f6ea9b0f6fcf6
来源：牛客网

public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }
    //前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
         
        if(startPre>endPre||startIn>endIn)
            return null;
        TreeNode root=new TreeNode(pre[startPre]);
         
        for(int i=startIn;i<=endIn;i++)
            if(in[i]==pre[startPre]){
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
                      break;
            }
                 
        return root;
    }
}

输入一个链表，输出该链表中倒数第k个结点。

 public ListNode FindKthToTail(ListNode head,int k) {
        ListNode p=head;
         if(head==null||k==0){
             return null;
         }
        for(int i=0;i<k-1;i++){//先走几步看看是否为空
           if(p.next!=null){
               p=p.next;
           }else{
               return null;
           }
        }
        while(p.next!=null){
            p=p.next;
            head=head.next;
        }
        return head;
    }

输入一个链表，反转链表后，输出新链表的表头。

 public ListNode ReverseList(ListNode head) {
         if(head==null){
             return null;
         }
    
        ListNode p=null;
        ListNode r=null;
        ListNode q=head;
        while(q!=null){
            r=q.next;
            q.next=p;
            p=q;
            q=r;
        }
        return p;
        
    }

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

private ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();
    private ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        if(root == null) return listAll;
        list.add(root.val);
        target -= root.val;
        if(target == 0 && root.left == null && root.right == null)
            listAll.add(new ArrayList<Integer>(list));
        FindPath(root.left, target);
        FindPath(root.right, target);
        list.remove(list.size()-1);
        return listAll;
    }

Binary Tree Level Order Traversal(层次遍历)

  public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lists=new ArrayList<List<Integer>>();
        if(root==null) return lists;
        List<Integer> list=new ArrayList<Integer>();
        lists.add(list);
        TreeNode flag=root; //标识此层最后一个元素
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);
            if(node.left!=null) queue.offer(node.left);
            if(node.right!=null) queue.offer(node.right);
            if(node==flag&&!queue.isEmpty()){
             list=new ArrayList();
               lists.add(list);
                flag=queue.getLast(); //队列的最后一个元素，此层最后一个元素
            }
        }
        return lists;
    }

连续子数组的最大和

 public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null||array.length==0){
            return 0;
            
        }
        int flag=array[0],sum=array[0];
        for(int i=1;i<array.length;i++){
            if(flag>=0) {
                flag+=array[i];
            }else{
                flag=array[i];
            }
            if(flag>sum) sum=flag;
           
        }
            return sum;
    }

最小的K个数

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
       ArrayList<Integer> list=new ArrayList<Integer>();
        if(input==null||k<=0||k>input.length) return list;
        PriorityQueue<Integer> queue=new PriorityQueue<Integer>();
        for(int i:input){
            queue.offer(i);
        }
        for(int i=0;i<k;i++){
            list.add(queue.poll());
        }
            return list;
    }