1. 二维数组中的查找
题目描述:
在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
解题思路:
每次选取矩阵右上角的元素 array[i][j] 与target进行比较。
当target小于元素 array[i][j] 时,由于此列向下递增,那么此列一定不存在符合题意的数,排除,即 j–;
当target大于元素 array[i][j] 时,由于此行向左递减,那么此行一定不存在符合题意的数,排除,即 i++;
public class Solution {
public boolean Find(int target, int [][] array) {
//方法1:暴力方法
// if(array.length == 0)
// return false;
// for(int i = 0; i < array.length; i++){
// for(int j=0; j < array[i].length; j++){
// if(target == array[i][j])
// return true;
// }
// }
// return false;
//方法2:采用二分查找的方式,把二分值定在右上角
int i = 0;
int j = array[i].length-1;
while(i<array.length && j>=0){
if(array[i][j] > target){
j--;
}else if(array[i][j] < target){
i++;
}else{
return true;
}
} return false;
}
}
2. 替换空格
题目描述:
请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路:
创建一个新的字符串,从前往后遍历原字符串,遇到字母添加原字母,遇到空格添加“%20”,最后输出新字符串。
public class Solution {
public String replaceSpace(StringBuffer str) {
// //方法1:调用内置函数
// return str.toString().replace(" ","%20");
//方法2:当遇到 " ",就追加 "%20",否则遇到什么追加什么
StringBuffer sb = new StringBuffer();
for(int i = 0; i < str.length(); i++){
char c = str.charAt(i);
if(c == ' ')
sb.append("%20");
else
sb.append(c);
}
return sb.toString();
}
}
3. 从尾到头打印链表
题目描述:
输入一个链表,按链表从尾到头的顺序返回一个ArrayList。
解题思路:
方法1:利用 ArraList 的 add(index, value) 方法在遍历链表的同时将每一次遍历得到的数据插入到 List 的头部
方法2:采用头插法翻转链表,然后重新遍历反转后的链表。
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
// //方法1:非递归,利用ArrayList中 add(index, value) 方法
// ArrayList<Integer> list = new ArrayList<>();
// ListNode temp = listNode;
// while(temp != null){
// list.add(0,temp.val);//指定位置插入元素
// temp = temp.next;
// }
// return list;
//方法1:头插法
ArrayList<Integer> list = new ArrayList<>();
ListNode newHead = new ListNode(-1);
newHead.next = null;
while(listNode != null){
ListNode next = listNode.next;
listNode.next = newHead.next;
newHead.next = listNode;
listNode = next;
}
ListNode next = newHead.next;
while(next != null){
list.add(next.val);
next = next.next;
}
return list;
}
}
4. 重建二叉树
题目描述:
输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。
解题思路:
1.根据前序序列第一个结点确定根结点
2.根据根结点在中序序列中的位置分割出左右两个子序列
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 函数,左闭右开
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. 用两个栈实现队列
题目描述:
用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路:
push操作就直接往stack1中push;
pop操作需要分类一下:如果stack2为空,那么需要将stack1中的数据转移到stack2中,然后在对stack2进行pop,如果stack2不为空,直接pop就可以。
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.isEmpty()){
while(!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
6. 旋转数组的最小数组
题目描述:
把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。
NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
解题思路:
二分查找的变种。这种二分查找难就难在,arr[mid]跟谁比。
我们的目的是:当进行一次比较时,一定能够确定答案在mid的某一侧。一次比较为 arr[mid]跟谁比的问题。
一般的比较原则有:
如果有目标值target,那么直接让arr[mid] 和 target 比较即可。
如果没有目标值,一般可以考虑 端点
这里我们把target 看作是右端点,来进行分析,那就要分析以下三种情况,看是否可以达到上述的目标(左端点会查找失败)。
令low和high分别指向数组的开始和结束位置,然后计算mid位置,然后与high处的值进行比较,有三种情况:
(1)array[high] < array[mid],让low = mid + 1
(2)array[high] > array[mid],让high = mid
(3)否则,high–
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length == 0 || array == null){
return 0;
}
int low = 0;
int high = array.length - 1;
int mid;
while(low < high){
mid = (low + high)/2;
if(array[mid] < array[high]){
high = mid;
}else if(array[mid] > array[high]){
low = mid + 1;
}else{
high--;
}
}
return array[low];
}
}
正常二分法的代码为:
public static int BinarySearch(int[] array,int key){
int low = 0;
int high = arr.length - 1;
int middle;
if(key < array[low] || key > array[high] || low > high){
return -1;
}
while(low <= high){
middle = (low + high) / 2;
if(array[middle] > key){
//比关键字大则关键字在左区域
high = middle - 1;
}else if(array[middle] < key){
//比关键字小则关键字在右区域
low = middle + 1;
}else{
return middle;
}
}
return -1; //最后仍然没有找到,则返回-1
}
7. 斐波那契数列
题目描述:
大家都知道斐波那契数列,现在要求输入一个整数n,请你输出斐波那契数列的第n项(从0开始,第0项为0,第1项是1,n≤39)。
解题思路:
F(0) = 0;
F(1) = 1;
F(2) = F(0)+F(1) = 1;
F(3) = F(1)+F(2) = 2;
F(4) = F(2)+F(3) = 3;
…
F(n) = F(n-2)+F(n-1)
public class Solution {
public int Fibonacci(int n) {
if(n == 0 || n == 1)
return n;
int a = 0;
int b = 1;
for(int i = 2; i <= n; i++){
b = a + b;
a = b - a;
}
return b;
}
}
8. 跳台阶
题目描述:
一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。
解题思路:
假设 F[i]表示在第 i 个台阶上可能的方法数。逆向思维。
如果我从第n个台阶进行下台阶,下一步有2中可能,一种走到第n-1个台阶,一种是走到第n-2个台阶。所以 F[n] = F[n-1] + F[n-2].
显然初始条件 F[0] = F[1] = 1
public class Solution {
public int JumpFloor(int target) {
//f[n] = f[n-1] + f[n-2]
if(target == 1 || target == 2){
return target;
}
int a = 1;
int b = 2;
for(int i = 3; i <= target; i++){
b = a + b;
a = b - a;
}
return b;
}
}
9. 变态跳台阶
题目描述:
一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
解题思路:
F[i] 表示 当前跳道第 i 个台阶的方法数。
假设现在已经跳到了第 n 个台阶,那么前一步可以从哪些台阶到达呢?
如果上一步跳 1 步到达第 n 个台阶,说明上一步在第 n-1 个台阶。已知跳到第n-1个台阶的方法数为 F[n-1]
如果上一步跳 2 步到达第 n 个台阶,说明上一步在第 n-2 个台阶。已知跳到第n-2个台阶的方法数为 F[n-2]
… …
如果上一步跳 n 步到达第 n 个台阶,说明上一步在第 0 个台阶。已知跳到 第0个台阶的方法数为f[0]
那么总的方法数就是所有可能的和。也就是 F[n] = F[n-1] + F[n-2] + … + F[0]
显然初始条件 F[0] = F[1] = 1
public class Solution {
public int JumpFloorII(int target) {
// if(target == 0 || target == 1){
// return 1;
// }
// return (int)Math.pow(2, target-1);
return 1<<(target-1);
}
}
10. 矩形覆盖
题目描述:
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形,总共有多少种方法?
解题思路:
F[n]表示 2*n 大矩阵的方法数。
可以得出:F[n] = F[n-1] + F[n-2]
初始条件 F[1] = 1, F[2] =2
public class Solution {
public int RectCover(int target) {
if(target <= 2){
return target;
}
int a = 1;
int b = 2;
for (int i=3; i <= target; i++){
b = a + b;
a = b - a;
}
return b;
}
}