1. 【
二维数组中的查找】
2. 【 替换空格】
请实现一个函数,将一个字符串中的空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
3.【 从尾到头打印链表】
用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。
在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
// 两种思路
// 一种是:
// 把每一行看成有序递增的数组,
// 利用二分查找,
// 通过遍历每一行得到答案,
// 时间复杂度是nlogn
public class Solution {
public boolean Find(int t, int [][] arr) {
if(arr.length==0&&arr[0].length==0){
return false;
}
for(int i=0;i<arr.length;i++){
int low = 0,high = arr[0].length-1;
int mid = 0;
while(low <= high){
mid = (low+high)/2;
if(arr[i][mid]<t){
low = mid+1;
}else if(arr[i][mid]>t){
high = mid-1;
}else{
return true;
}
}
}
return false;
}
}
//另外一种思路是:
//利用二维数组由上到下,由左到右递增的规律,
//那么选取右上角或者左下角的元素a[row][col]与target进行比较,
//当target小于元素a[row][col]时,那么target必定在元素a所在行的左边,
//即col--;
//当target大于元素a[row][col]时,那么target必定在元素a所在列的下边,
//即row++;
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(target==array[row][col])
return true;
else if(target>array[row][col])
row++;
else
col--;
}
return false;
}
}
2. 【 替换空格】
请实现一个函数,将一个字符串中的空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
public class Solution {
public String replaceSpace(StringBuffer str) {
if(str==null){
return null;
}
StringBuffer sb = new StringBuffer();
for(int i=0;i<str.length();i++){
if(str.charAt(i)!=' ' ){
sb.append(str.charAt(i));
}else{
sb.append("%20");
}
}
return sb.toString();
}
}
3.【 从尾到头打印链表】
输入一个链表,从尾到头打印链表每个节点的值。
/*
* 方法一: 改变链表结构
* 从头到尾--》 从尾到头
* 顺序遍历打印即可
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode h) {
ArrayList<Integer> list = new ArrayList<Integer>();
ListNode pre = null,next = null;
while(h!=null){
next = h.next;
h.next = pre;
pre = h;
h = next;
}
h = pre;
while(h!=null){
list.add(h.val);
h = h.next;
}
return list;
}
}
/**
* 方法二: 超牛逼的递归解法!
*/
import java.util.ArrayList;
public class Solution {
ArrayList<Integer> arrayList=new ArrayList<Integer>();
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode!=null){
this.printListFromTailToHead(listNode.next);
arrayList.add(listNode.val);
}
return arrayList;
}
}
4.【
用两个栈实现队列】
见
http://blog.csdn.net/m0_37955444/article/details/78539056
5. 【
旋转数组的最小数字】
把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。 NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
现在要求输入一个整数n,请你输出斐波那契数列的第n项。
//
//采用二分法解答这个问题,
//mid = low + (high - low)/2
//需要考虑三种情况:
//(1)array[mid] > array[high]:
//出现这种情况的array类似[3,4,5,6,0,1,2],此时最小数字一定在mid的右边。
//low = mid + 1
//(2)array[mid] == array[high]:
//出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1],此时最小数字不好判断在mid左边
//还是右边,这时只好一个一个试 ,
//high = high - 1
//(3)array[mid] < array[high]:
//出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左
//边。因为右边必然都是递增的。
//high = mid
//注意这里有个坑:如果待查询的范围最后只剩两个数,那么mid 一定会指向下标靠前的数字
//比如 array = [4,6]
//array[low] = 4 ;array[mid] = 4 ; array[high] = 6 ;
//如果high = mid - 1,就会产生错误, 因此high = mid
//但情形(1)中low = mid + 1就不会错误
public class Solution {
public int minNumberInRotateArray(int [] array) {
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;
}else if(array[mid] == array[high]){
high = high - 1;
}else{
high = mid;
}
}
return array[low];
}
}
6. 【
斐波那契数列】
现在要求输入一个整数n,请你输出斐波那契数列的第n项。
/*
*方法一:递归,不考虑,有大量的重复计算,会导致内存溢出
*/
public class Solution {
public int Fibonacci(int n) {
if(n<=0) {
return 0;
}
if(n==1) {
return 1;
}
returnFibonacci(n-2)+Fibonacci(n-1);
}
}
/*
*方法二:使用迭代法,用fn1和fn2保存计算过程中的结果,并复用起来
*/
public class Solution {
public int Fibonacci(int n) {
int fn1 = 1;
int fn2 = 1;
if(n <= 0 ) {
return 0;
}
if(n==1 || n==2) {
return 1;
}
while(n>2) {
fn1 += fn2;
fn2 = fn1-fn2;
n--;
}
return fn1;
}
}