1. 二维数组中的查找
1.1 题目描述
- 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
1.2 题目分析
-
一个二维数组如图1
-
要查找数组7在不在数组内，我们可以选择从数组的右上角的点开始比较，此时该值为9，9>7，同时9还是第四列最小的数字，那么这意味着，第四列都不可能找到7，于是我们可以直接删除第四列。
-
蓝色代表所在的行或者列已经排查完了，红色代表当前值。此时值为8，显然和之前的结果一样，如图2。
-
然后我们比较2与7，2<7，同时2的位置是当前行内最大的数值，这意味着该行内不可能找到7，于是删除该行，如图3 。
-
4与2的情况相同，直接删除该行，如图4。
-
最后我们找到了7，如图5 。
这个思路关键的地方在于右上角点的选取，因为这个点的值是所在列的最小值和所在行的最大值，这就意味着：
要查找的数值如果比右上角的值大，那么它将大于整个行；
要查找的数值比如果右上角的值小，那么它将小于整个列。
如果相等的话，查找就结束了~~~
所以无论是哪一种情况，都可以让我们删除一个行或一个列，下一次要比较的那个值就是删除后的二维数组的右上角的值，总之永远在用右上角的值在比较。
这个一个最大一个最小的特性，**除了右上角的点之外，左下角也是满足的 **。
1.3 题目代码
public class Solution {
public boolean Find(int target, int [][] array) {
int row = 0;
int cols = array[0].length - 1;
while(row <= array.length-1 && cols >= 0){
if(array[row][cols] == target){
return true;
}else if(target < array[row][cols]){
cols--;
}else{
row++;
}
}
return false;
}
}
2. 替换空格
2.1 题目描述
-
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为
We%20Are%20Happy。
2.2 题目分析
- 先将String字符串转换为Char 数组，遍历一遍char数组统计出字符串中空格的总长度，因每次替换一个空格长度+2；故所需的总长度为
lenth + Count * 2。
2.3 题目代码
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param s string字符串
* @return string字符串
*/
public String replaceSpace (String s) {
// write code here
char[] chars =s.toCharArray();
int length =chars.length;
int count = 0;
for(char c : chars){
if(c == ' '){
count++;
}
}
char[] res = new char[length + 2*count];
int j = 0;
for(int i = 0;i < length; i++){
if(chars[i] == ' ' ){
res[j] = '%';
res[j+1] = '2';
res[j+2] = '0';
j = j + 3;
}else{
res[j] = chars[i];
j++;
}
}
return new String(res);
}
}
3. 从尾到头打印链表
3.1 题目描述
- 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
3.2 题目分析
这个题目可以有三种做法：
- 1）使用用栈基于循环实现
- 2）使用递归实现
本质也是一个栈结构，要实现反过来输出链表，我们每访问到一个节点的时候，先递归输出它后面的节点，再输出该节点本身，这样链表的输出结果就反过来了。 - 3）存储到数组或者其他容器，然后倒着遍历（不推荐）
这里主要利用栈和使用递归实现两种方式：具体代码如下
3.3 题目代码
3.3.1 用栈基于循环实现
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
//1.用栈基于循环实现
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack =new Stack<Integer>();
while(listNode != null){
stack.add(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> res =new ArrayList<Integer>();
while(!stack.isEmpty()){
res.add(stack.pop());
}
return res;
}
}
3.3.2 递归方法实现
/**
* public class ListNode {
* int val;
* ListNode next = null;
* * ListNode(int val) {
* this.val = val;
* }
* }
* */
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
//2.利用递归实现
ArrayList<Integer> res = new ArrayList<Integer>();
if(listNode != null){
res.addAll(printListFromTailToHead(listNode.next));
res.add(listNode.val);
}
return res;
}
}
4. 重建二叉树
4.1 题目描述
- 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
4.2 题目分析
根据中序遍历和前序遍历可以确定二叉树，具体过程为：
-
根据前序序列第一个结点确定根结点
-
根据根结点在中序序列中的位置分割出左右两个子序列
-
对左子树和右子树分别递归使用同样的方法继续分解
例如： 前序序列{1,2,4,7,3,5,6,8} = pre 中序序列{4,7,2,1,5,3,8,6} = in
-
根据当前前序序列的第一个结点确定根结点，为 1
-
找到 1 在中序遍历序列中的位置，为 in[3]
-
切割左右子树，则 in[3] 前面的为左子树， in[3] 后面的为右子树
-
则切割后的左子树前序序列为：{2,4,7}，切割后的左子树中序序列为：{4,7,2}；切割后的右子树前序序列为：{3,5,6,8}，切割后的右子树中序序列为：{5,3,8,6}
-
对子树分别使用同样的方法分解
补充
二叉树的遍历分成三种，按照根节点的访问先后分为：
先序遍历（先根遍历）：先访问根节点，然后访问左子树， 最后访问右子树。
中序遍历（中根遍历）：先访问左子树，然后访问根节点， 最后访问右子树。
后续遍历（后根遍历）：先访问左子树，然后访问右子树，最后访问根节点。
- 先序，后序遍历可以确定根节点。
- 中序遍历可以确定左子树和右子树。
4.3 题目代码
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
//递归调用的终止条件
if(pre.length == 0 || in.length == 0){
return null;
}
//由前序遍历得到该二叉树的根结点
TreeNode root =new TreeNode(pre[0]);
//在中序遍历中找根结点位置，进行左右子树的划分
for(int i =0;i< in.length ;i++){
if(in[i] == pre[0]){
//将左子树看成一棵二叉树调用该方法，可以得到左子树根结点，即上面根结点的左子结点
//copyOfRange(original,int from,int to)该方法返回一个长度为to-from的数组
root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
//将右子树看成一棵二叉树调用该方法，可以得到右子树根结点，即上面根结点的右子结点
root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
//找到根结点位置便跳出循环
break;
}
}
return root;
}
}
5. 用两个栈实现队列
5.1 题目描述
- 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
5.2 题目分析
队列的特性是：“先入先出”，栈的特性是：“先入后出”
当我们向模拟的队列插入数 a,b,c 时，假设插入的是 stack1，此时的栈情况为：
- 栈 stack1：{a,b,c}
- 栈 stack2：{}
当需要弹出一个数，根据队列的"先进先出"原则，a 先进入，则 a 应该先弹出。但是此时 a 在 stack1 的最下面，将 stack1 中全部元素逐个弹出压入 stack2，现在可以正确的从 stack2 中弹出 a，此时的栈情况为：
-
栈 stack1：{}
-
栈 stack2：{c,b}
继续弹出一个数，b 比 c 先进入"队列"，b 弹出，注意此时 b 在 stack2 的栈顶，可直接弹出，此时的栈情况为：
-
栈 stack1：{}
-
栈 stack2：{c}
此时向模拟队列插入一个数 d，还是插入 stack1，此时的栈情况：
-
栈 stack1：{d}
-
栈 stack2：{c}
弹出一个数，c 比 d 先进入，c 弹出，注意此时 c 在 stack2 的栈顶，可直接弹出，此时的栈情况为：
-
栈 stack1：{d}
-
栈 stack2：{}
此时，stack2为空，stack1中的数字全部压入stack2中，此时栈的情况为：
-
栈 stack1：{}
-
栈 stack2：{d}
此时，stack2不为空，直接弹出。
根据上述例子可得出结论：
-
当插入时，直接插入 stack1
-
当弹出时，当 stack2 不为空，弹出 stack2 栈顶元素，如果 stack2 为空，将 stack1 中的全部数逐个出栈入栈
stack2，再弹出 stack2 栈顶元素
5.3 题目代码
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() {
Integer a=null;
//如果栈2不是空的，那么把最上面那个取出来
if(!stack2.empty()){
a=stack2.pop();
}else{
//如果栈2是空的，就把栈1里的数一个个取出来，放到栈2里
while(!stack1.empty()){
stack2.push(stack1.pop());
}
//栈2里有数之后，再次把里面的数取出来
if(!stack2.empty()){
a=stack2.pop();
}
}
return a;
}
}
6. 旋转数组的最小数字
6.1 题目描述
-
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
-
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
6.2 题目分析
6.3 题目代码
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length == 0){
return 0;
}
int left = 0;
int right = array.length - 1;
while(left < right){
int mid = (left + right) >> 1;
if (array[mid] <= array[right]){
right = mid;
}else if(array[mid] >= array[right]){
left = mid+1;
}
}
return array[right];
}
}
7. 用两个栈实现队列
7.1 题目描述
- 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。(每种方法的分析均写到代码前的注释一行)
- n≤39
7.2 题目分析
斐波那契数列的标准公式为：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）
-
递归法：
原理： 把 f(n) 问题的计算拆分成 f(n−1) 和 f(n−2)两个子问题的计算，并递归，以 f(0) 和 f(1) 为终止条件。
缺点： 大量重复的递归计算，例如 f(n) 和 f(n−1) 两者向下递归都需要计算 f(n−2)的值。 -
记忆化递归法：
原理： 在递归法的基础上，新建一个长度为 nnn 的数组，用于在递归时存储 f(0)至 f(n)的数字值，重复遇到某数字时则直接从数组取用，避免了重复的递归计算。
缺点： 记忆化存储的数组需要使用 O(N) 的额外空间。 -
动态规划：
原理： 以斐波那契数列性质 f(n+1)=f(n)+f(n−1)为转移方程。
从计算效率、空间复杂度上看，动态规划是本题的最佳解法。
7.3 题目代码
7.3.1 普通递归法
public class Solution {
public int Fibonacci(int n) {
if(n <= 1){
return n;
}
return Fibonacci(n-1) + Fibonacci(n-2);
}
}
7.3.2 记忆化递归法
//递归会重复计算大量相同数据，我们用个数组把结果存起来
public class Solution {
public int Fibonacci(int n) {
int ans[] = new int[40];
ans[0] = 0;
ans[1] = 1;
for(int i = 2;i<= n;i++){
ans[i] = ans[i-1]+ans[i-2];
}
return ans[n];
}
}
7.3.3 动态规划法
//其实我们可以发现每次就用到了最近的两个数，
//所以我们可以只存储最近的两个数
public class Solution {
public int Fibonacci(int n) {
if(n==0){
return 0;
}else if(n==1){
return 1;
}
int sum = 0;//用于存储当前所求的数
int one = 1;//存储第 n-1 项的值
int two = 0;//存储第 n-2 项的值
for(int i = 2 ; i<=n ;i++){
sum = one + two;
two = one;//先把之前的one值赋给two
one = sum;//再把新的sum值赋给one
}
return sum;
}
}
7.3.4 动态规划的持续优化
/**
上一版发现，sum 只在每次计算第 n 项的时候用一下，其实还可以利用 sum 存储第 n-1 项，
例如当计算完 f(5) 时 sum 存储的是 f(5) 的值，当需要计算 f(6) 时，f(6) = f(5) + f(4)，
sum 存储的 f(5)，f(4) 存储在 one 中，由 f(5)-f(3) 得到
*/
public class Solution {
public int Fibonacci(int n) {
if(n==0){
return 0;
}else if(n==1){
return 1;
}
int sum = 1;//用于存储当前所求的数 并且可以当作下一个值的前一项，即n-1项
int one = 0;//存储第 n-2 项的值
for(int i = 2 ; i<=n ;i++){
sum = sum + one;
one = sum - one;//one值就是原来的sum值
}
return sum;
}
}
8. 跳台阶
8.1 题目描述
- 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。(每种方法的分析均写到代码前的注释一行)
- n≤39
8.2 题目分析
设跳上 n级台阶有 f(n) 种跳法。在所有跳法中，青蛙的最后一步只有两种情况： 跳上 1 级或 2 级台阶。
- 当为 1级台阶： 剩 n−1 个台阶，此情况共有 f(n−1) 种跳法；
- 当为 2级台阶： 剩 n−2 个台阶，此情况共有 f(n−2) 种跳法。
f(n)为以上两种情况之和，即 f(n)=f(n−1)+f(n−2)，以上递推性质为斐波那契数列。本题可转化为 求斐波那契数列第 n项的值 ，与 面试题斐波那契数列 等价，唯一的不同在于起始数字不同。
-
青蛙跳台阶问题： f(0)=1 , f(1)=1, f(2)=2
-
斐波那契数列问题： f(0)=0 , f(1)=1 , f(2)=1 。
本题使用动态规划法求解： -
大数越界:随着 target 增大, f(n) 会超过 Int32 甚至 Int64 的取值范围，导致最终的返回值错误。
8.3 题目代码
public class Solution {
public int JumpFloor(int target) {
if(target <= 1){
return 1;
}
int two = 1;
int one = 1,sum = 0;
for(int i = 2 ; i <= target ;i++){
// 大数越界:随着 target 增大, f(n) 会超过 Int32 甚至 Int64 的取值范围，导致最终的返回值错误。
sum = (one + two)% 1000000007;
//在leetCode中% 1000000007 防止溢出，当target>=44时，会出现溢出
two = one;
one = sum;
}
return sum;
}
}
9. 变态跳台阶
9.1 题目描述
- 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。(每种方法的分析均写到代码前的注释一行)
- n≤39
9.2 题目分析
设跳上 n级台阶有 f(n) 种跳法。在所有跳法中，青蛙的最后一步只有两种情况： 跳上 1 级或 2 级台阶。
- 当为 1级台阶： 剩 n−1 个台阶，此情况共有 f(n−1) 种跳法；
- 当为 2级台阶： 剩 n−2 个台阶，此情况共有 f(n−2) 种跳法。
f(n)为以上两种情况之和，即 f(n)=f(n−1)+f(n−2)，以上递推性质为斐波那契数列。本题可转化为 求斐波那契数列第 n项的值 ，与 面试题斐波那契数列 等价，唯一的不同在于起始数字不同。
-
青蛙跳台阶问题： f(0)=1 , f(1)=1, f(2)=2
-
斐波那契数列问题： f(0)=0 , f(1)=1 , f(2)=1 。
本题使用动态规划法求解： -
大数越界:随着 target 增大, f(n) 会超过 Int32 甚至 Int64 的取值范围，导致最终的返回值错误。