剑指offer1-10

二维数组的查找：

public class Solution {
    public boolean Find(int target, int [][] array) {
        if((array.length==0)||array==null)
        {
            return false;
        }
        int m=array.length;//二维数组的行数
        int n=array[0].length;//二维数组的列数
        int r=0;
        int c=n-1;
        while(r<m&&c>=0)
        {
            if(array[r][c]==target)
            {
                return true;
            }
            else if(array[r][c]>target)
            {
                c--;
            }
            else
            {
                r++;
            }
             
        }
        return false;
         
 
    }
}

替换空格：

public class Solution {
    public String replaceSpace(StringBuffer str) {
        if(str==null)
        {
            return null;
        }
        for(int i=0;i<str.length();i++)
        {
            if(str.charAt(i)==' ')
            {
                str.replace(i,i+1,"%20");
            }
        }
        return str.toString();
         
    }
}

从尾到头打印链表

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.Stack;
import java.util.ArrayList;
public class Solution{
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack <Integer>stack=new Stack<Integer>();
        while(listNode!=null)
        {
            stack.push(listNode.val);
            listNode=listNode.next;
        }
        ArrayList <Integer>list=new ArrayList<Integer>();
        while(!stack.isEmpty()) {
                list.add(stack.pop());
        }
        return list;
    }
}

重建二叉树：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
	public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
	    TreeNode root=reConstructBinaryTree1(pre,0,pre.length-1,in,0,in.length-1);
		return root;
	}
	private TreeNode reConstructBinaryTree1(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=reConstructBinaryTree1(pre,startpre+1,startpre+i-startin,in,startin,i-1);
				root.right=reConstructBinaryTree1(pre,i-startin+startpre+1,endpre,in,i+1,endin);
				break;
			}
            //先通过前序遍历的第一个找出二叉树的根节点，在通过中序遍历确定二叉树的左子树和右子树，进行递归查找
            //startpre+1代表下一次递归找到的通过前序遍历找到的根节点
            //startpre+i-startin就是用前序遍历的开始遍历的地方加上左子树的节点个数（i-startin）也就是遍历的范围、
            //i-startin+startpre+1就是上边遍历的范围加一
		}
		return root;
		
	}
}

用两个栈实现队列：

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
       if(stack2.empty()){
            while(!stack1.empty())
                stack2.push(stack1.pop());
        }
        
        return stack2.pop();
    
    }
}

旋转数组的最小数字：

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        //非递减排序：122334567789
        if(array.length==0)
            return 0;
        int low=0;
        int high=array.length-1;
        while(low<high)
        {
            int mid=low+(high-low)/2;
            if(array[mid]>array[high])
                low=mid+1;//适用于3,4,5,1，2这种情况
            else if(array[mid]==array[high])
                high=high-1;//0,1，1,1,1的旋转数组可以是1，0,1,1,1或者是1,1,1,0,1所以最小值不确定
            else
                high=mid;//适用于2，2,3,4,5,6，6最小值肯定是arra[mid]或者在他的左边
        }
        return array[low];
    }
}

菲波那切数列：

public class Solution {
    public int Fibonacci(int n) {
        if(n==1)
            return 1;
        if(n==0)
            return 0;
        int array[]=new int[n+1];
        array[1]=1;
        for(int i=2;i<=n;i++)
        {
            array[i]=array[i-1]+array[i-2];
        }
        return array[n];

    }
}

跳台阶：

public class Solution {
    public int JumpFloor(int target) {
       if(target==0)
           return 0;
        if(target==1)
           return 1;
        if(target==2)
           return 2;
        int array[]=new int[target+1];
        array[1]=1;
        array[2]=2;
        for(int i=3;i<=target;i++)
        {           
            array[i]=array[i-1]+array[i-2];
        }
        return array[target];
//可以看做一个斐波那契数列来看     当跳到第六个台阶的时候，往前退一步有两种走法，第一种从第五步直接跳到第六步
        //所以跳到第五步有多少种方法就有多少种方法第二种从第四步直接跳到第六步同理所以f（6）=f（5）+f（4）
    }
}

变态跳台阶：

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

矩形覆盖：

public class Solution {
    public int RectCover(int target) {
        if(target==1)
            return 1;
        else if(target==2)
            return 2;
        else if(target<1)
            return 0;
        else 
            return RectCover(target-1)+RectCover(target-2);
         
        //假设有一个2*4的矩形，覆盖的最后一步可以是2*1这样的矩形块，只需要RectCover（3）或者是1*2的矩形块是
        //RectCover（2）
        

    }
}