剑指offer 1~10

剑指offer 1~10

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

public class Solution {
    public boolean Find(int target, int [][] array) {
        int row = 0;
        int col = array[0].length-1;
        while(row <= array.length-1 && col >= 0){
            if(array[row][col] < target) row++;
            else if(array[row][col] > target)col--;
            else return true;
        }
        return false;
    }
}

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

public class Solution {
    public String replaceSpace(StringBuffer str) {
        StringBuffer sb = new StringBuffer();
		 for(int i = 0 ;i <str.length();i++) {
			 if(str.charAt(i)==' ') 
				 sb.append("%20");
			 else sb.append(str.charAt(i));
		 }
        return sb.toString();    	
    }
}

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

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

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

/**
 * 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 = new TreeNode(pre[0]);
        if (pre.length == 1) {
            root.left = null;
            root.right = null;
            return root;
        }
        int len = pre.length;
        int i;
        for (i = 0; i < len; i++) {
            if (pre[0] == in[i]) {
                break;
            }
        }
        //重建左子树
        if (i > 0) {
            int pr[] = new int[i];
            int ino[] = new int[i];
            for (int j = 0; j < i; j++) {
                pr[j] = pre[j + 1];
            }
            for (int j = 0; j < i; j++) {
                ino[j] = in[j];
            }
            root.left = reConstructBinaryTree(pr, ino);
        } else {
            root.left = null;
        }
        //重建右子树
        if (len - i - 1 > 0) {
            int pr[] = new int[len - i - 1];
            int ino[] = new int[len - i - 1];
            for (int j = i + 1; j < len; j++) {
                pr[j - i - 1] = pre[j];
                ino[j - i - 1] = in[j];
            }
            root.right = reConstructBinaryTree(pr, ino);
        } else {
            root.right = null;
        }
        return root;
    }
}

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

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();
    }
}

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int high = array.length-1;
		int low = 0;
		while(low<high) {
			int mid = (low+high)/2;
			if(array[mid]>array[high]) {
				low=mid+1;
			}
			else if(array[mid] == array[high])high=high-1;
			else high=mid;
		}
		return array[high];
    }
}

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n<=39

class Solution {
public:
    int Fibonacci(int n) {
        int a = 1, b = 1, c=0;
		if (n <= 0)return 0;
		if(n==1||n==2)
			return 1;
		for(int i=3;i<=n;i++) {
			c=a+b;
			a=b;
			b=c;
		}
		return c;
	}
};

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

class Solution {
public:
    int jumpFloor(int number) {
        int a = 1, b = 2, c = 0;
		if (number == 1)
			return 1;
		if (number == 2)
			return 2;
		for (int i = 3; i <= number; i++) {
			c = a + b;
			a = b;
			b = c;
		}
		return c;
	
    }
};

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

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);
		
    }
}

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

public class Solution {
    public int RectCover(int target) {
        int a = 1, b = 1, c = 0;
		if (target == 0)
			return 0;
		if (target == 1)
			return 1;
		for (int i = 2; i <= target; i++) {
			c = a + b;
			b = a;
			a = c;
		}
		return c;
    }
}