剑指offer 算法java

最新推荐文章于 2020-07-23 21:07:32 发布

Mis_wenwen

最新推荐文章于 2020-07-23 21:07:32 发布

阅读量547

点赞数

本文链接：https://blog.csdn.net/Mis_wenwen/article/details/72772374

版权

1.将字符串转化为数字

char'0'对应48'A'对应65'a'对应97

(1)简单点就是调用javaapi。

inta=Integer.parseInt(“123”);

这样得到a=123。

(2)将string分解成一个个的char.然后将char转化为int。个位不需要乘，十位乘以10，百分乘以100，以此类推。

<1>string分解为一个个的char.

c语言中:

Stringa=”123”;

charx=a[0];

java中:

Stringa=”123”;

charx=a.charAt(0);

<2>将char转化为int

我们知道char是使用的ASCII码。

标准ASCII码也叫基础ASCII码，使用7位二进制数（剩下的1位二进制为0）来表示所有的大写和小写字母，数字0到9、标点符号，以及在美式英语中使用的特殊控制字符。

int result;
char codePoint=a.charAt(0);
  if ('0' <= codePoint && codePoint <= '9') {
                result = codePoint - '0';
            } else if ('a' <= codePoint && codePoint <= 'z') {
                result = 10 + (codePoint - 'a');
            } else if ('A' <= codePoint && codePoint <= 'Z') {
                result = 10 + (codePoint - 'A');

<3>简单的来写的话

String a="12345"; 
int num=0; 
int total=a.charAt(a.length()-1)-'0'; 
System.out.println(total); 
char x; 
for(int i=0;i<a.length()-1;i++){ 
	x=a.charAt(i); 
	System.out.println(x); 
	num=x-'0'; 
	System.out.println(num); 
total=(int) (total+num*Math.pow(10, a.length()-1-i)); 
} 
System.out.println(total);

我们用到了指数，所以调用Math.pow方法。

<4>这么写其实有很多点没有考虑到

例如：

字符串是否为空字符串
字符串是否为null
字符串是否只有一位为零
字符串中有负号
字符串中有非数字字符
字符串的边界条件，比如Stringa=“9999999999999999999999999999”,要考虑到最大的正正数和最小的负整数以及溢出。

如果有负号Stringa=“-12345”

代码如下更改

String mString=“54321”
int state;
private static final int IS_PLUS=1;
private static final int IS_NEGATIVE=2;
private static final int IS_OVERFLOW=3;
private static final int ERROR=4;
...
public static void main(String[] args){
StateJudge(String target);//判断是哪种情况
switch(state){
	case  IS_PLUS:
	ransferPlus(mString);
	break;
	case IS_NEGATIVE:
	transferNegative(mString);
	break;
	case IS_OVERFLOW:
	isOverflow();
	break;
	case ERROR:
	isError();
	break;
	...
	default:
	break;

}
}
tranferPlus(String target){}
transferNegative(String target){}
isOverflow(){}
isError(){}
StateJudge(String target){}

2.将整形转化为字符串

(1)调用javaapi

Strings=String.valueOf(int a);其他类型也是可以的。

(2)

<1>将int转化为一个个char,先除再求余

举个例子654321

获得1:654321%10

获得2:(654321/10)%10

获得3:(654321/100)%10

获得4:(654321/1000)%10

获得5:(654321/10000)%10

获得6:(654321/100000)%10

chara1=6+'0';

chara2=5+'0';

<2>将char拼接成String

chara='a';

charb='b';

Strings=“”+a+b;

注意前面要加个空字符串，这样才是String类型。否则是int类型的计算。相当于是97+98

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

获得二维数组的行数和列数方法：

int row=array.length();

int col=array[0].length();

public class Matrix { 
	public static void main(String[] args) { 
		// TODO Auto-generated method stub 
int[][] a={ 
					{1,2,8,9}, 
					{2,4,9,12}, 
					{4,7,10,13}, 
					{6,8,11,15} 
					}; 
boolean found=false; 
int target=16; 
int row=0; 
int col=3; 
while(col>=0&&row<=3) 
{if(a[row][col]==target) 
	{found=true; 
   break;} 
else if(a[row][col]>target) 
	col--; 
else{ 
	row++; 
} 

	} 
System.out.println(found); 

	} 

}

4.Strings = null; 拼接问题

Strings = null;

s+= "abc";

System.out.println(s);

答案是nullabc.

5.请实现一个函数，把字符串中的每个空格替换成”%20”。例如输入“Weare happy.”,则输出”We%20are%20happy.”。

(1)调用api

String mString2=mString1.replace(“”,”%20”);

如果是替换字符的话还可以用

StringmString2=mString1.replace('','x');

分别对应两个方法：

publicString replace(CharSequence target, CharSequence replacement) {}

publicString replace(char oldChar, char newChar) { }

(2)自己实现代码

代码如下：

class StringTest { 
	public static void main(String[] args) { 
		// TODO Auto-generated method stub 
		String mString = "we are happy!Today is a good day! "; 
		int num = 0; 
		int startLength = mString.length(); 
		for (int i = 0; i < startLength; i++) { 
			if (mString.charAt(i) == ' ') { 
				num++; 
			} 
		} 
		int finishLength = startLength + 2 * num; //获取新的字符串长度
		int indexOfOriginal = startLength-1; 
		int indexOfNew = finishLength-1; 
		char[] aa = new char[finishLength]; //定义类型为char的数组
		while (indexOfNew>=0&&indexOfNew>=indexOfOriginal) { 
			if (mString.charAt(indexOfOriginal) != ' ') { 
				aa[indexOfNew--] = mString.charAt(indexOfOriginal); 
			} else { 
				aa[indexOfNew--] = '0'; 
				aa[indexOfNew--] = '2'; 
				aa[indexOfNew--] = '%'; 
			} 
			--indexOfOriginal; 
		} 
		String mNewString = String.valueOf(aa); //将char类型数组转化为String
		System.out.println(mString); 
		System.out.println(mNewString); 
	} 
}

6.已知有一个数列，f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n);其中ｎ是大于０的整数，求f(10)的值。

recursion：递归

class Recursion {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(fn(10));
	}

	private static int fn(int i) {
		// TODO Auto-generated method stub
		if (i == 1) {
			return 1;
		} else if (i == 2) {
			return 4;
		} else {
			return 2 * fn(i - 1) + fn(i - 2);
		}
	}
}

7.实现一个排序算法，要求时间效率为O(n)

思路：首先员工年龄是有范围的。统计出每个年龄出现的次数。某年龄出现n次，就在数组里设置几次改年龄。相当于排序了。

注意要考虑到输入的异常情况并处理，比如年龄大于100，小于0的错误输入情况。

循环100×n，时间复杂度为O(n).

代码如下：

	public static void ageSort(int[] age) {
		int length = age.length;
		int[] sortedAge = new int[length];
		int[] timesOfAge;
		int maxAge = 99;
		timesOfAge = new int[maxAge + 1];
		for (int i = 0; i < timesOfAge.length; i++) {
			for (int j = 0; j < length; j++) {
				if (age[j] == i) {
					timesOfAge[i]++;
				}
			}
		}
		int index = 0;
		for (int i = 0; i < timesOfAge.length; i++) {
			for (int j = 0; j < timesOfAge[i]; j++) {
				sortedAge[index] = i;
				index++;
			}
		}
	}

8.java实现二分法

采用二分法查找时，数据需是有序不重复的。这里按升序来排序。

	public static int dichotomy(int[] array, int num) {
		int index=0;
		int start=0;
		int end=array.length-1;
		while (start<=end) {
			index=(start+end)/2;
			if (num<array[index]) {
				end=index-1;
			}
			else if (num>array[index]) {
				start=index+1;
			} 
			else {
				return index;
			}
		}
		return -1;
	}

总结：详细揣摩whle(start<=end)这句循环。

如果num不在array里面，并且比最后一个数大。

start与end的变化情况，循环倒数第二次肯定是start=end.(start不断变大)，最后一次start+1变的大于end。退出循环，没找到。

如果num不在array里面，并且比第一个数小。

start与end的变化情况，循环倒数第二次肯定是start=end.(end不断变小)，最后一次end-1变的小于start。退出循环，没找到。

9.旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转，输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值。

直观解法：遍历数组，求除最小值。事件复杂度O(n).不满足要求。

规律：

(1)可以划分为两个排序的子数组，而且前面的子数组的元素都大于或者等于后面子数组的元素。

(2)最小的元素刚好是这两个子数组的分界线。

所以采用二分查找法实现O(logn)的查找。

要考虑其它特殊情况：

如果把排序数组的前面的0个元素搬到最后。这样就不会满足第一个元素总是大于或者等于最后一个元素。

比如有重复数字的情况。

代码：

	public static int findMinIndex(int[] array) {
		int index = 0;
		int middle=0;
		int start=0;
		int end=array.length-1;
		while(start<end){
			middle=(start+end)/2;
			if (array[middle]>array[start]) {
				start=middle;
			}
			else if (array[middle]<array[start]) {
				end=middle;
			}
			else {
				index=end;
				break;
			}
		}
		return index;
	}
}

最后一次查找后，end比start多1.index就是end。

总结来说的话：除了没有任何规律的数组可以考虑用遍历，其他的都不会考虑优先遍历。

10.java实现冒泡排序

冒泡排序排序的总次数：n(n-1)/2

时间复杂度为：O(n2)

步骤：原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

这样一趟过去后,最大或最小的数字被交换到了最后一位,

然后再从头开始进行两两比较交换。第一趟比较n次，那么最后一位是最大(小)的数。下一趟就不用再比较它了。

time=n+(n-1)+(n-2)+(n-3)+...0=n2-n(n+1)/2=n(n-1)/2

代码如下：

public static void bubbleSort(int[] a) {
		int temp=0;
		for (int i = a.length-1; i >0; i--) {
			for (int j = 0; j <i; j++) {
				if (a[j]>a[j+1]) {
					temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		}
	}

总结：好好揣摩

for(int i = a.length-1; i >0; i--) {

for(int j = 0; j <i; j++) {

}

这两句。

11斐波那契数列（Fibonaccisequence）

又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>2，n∈N*）
递归写法：

	public static int  getResult2(int n) {
		if (n<2) {
			return 1;
		}
		else {
			return getResult2(n-1)+getResult2(n-2);
		}
	}

明显效率大于O(n)。网上有推导说是O(n32n)（n的三次方乘以2的n次方）

循环写法：

	public static int getResult(int n) {
		int myResult = 0;
		int[] result = { 1, 1 };
		int first = result[0];
		int second = result[1];
		if (n < 2) {
			myResult = result[n];
		}
		for (int i = 2; i <= n; i++) {
			myResult = first + second;
			first = second;
			second = myResult;
		}
		return myResult;
	}

效率为O(n),面试建议用循环的写法来写。

12.二进制中１的个数

方法一：右移输入数(对于负数会造成死循环，原因是负数的符号为１)

输入数为正，循环次数为输入数转化成二进制的位数。

public static int numberOfOne(int num) {
		int count=0;
		while (num!=0) {
			if ((num&1)!=0) {
				count++;
			}
			num=num>>1;
		}
		return count;
	}

方法二：左移１

循环次数与int类型的储存位数有关，所以这里是３２次。

	public static int numberOfOne(int num) {
		int count = 0;
		int one = 1;
		while (one != 0) {
			if ((num & one) !=0) {
				count++;
			}
			one = one << 1;
			System.out.println("one"+one);
		}
		return count;
	}

one2one4one8one16one32one64one128one256one512one1024one2048one4096one8192one16384one32768one65536one131072one262144one524288one1048576one2097152one4194304one8388608one16777216one33554432one67108864one134217728one268435456one536870912one1073741824one-2147483648one0

13.代码实现Math.pow(doublebase,int exponent).实际是Math.pow(doublebase,double exponet);

自以为简单的想法：

double pow(double base,int exponent){
	double result=1.0;
	for(int i=0;i<=exponent,i++){
		result*=base;
	}
	return result;
}

这样写没有考虑０，负数的情况。

先说指数为负数：

负数取绝对值，然后求结果，最后将结果求倒数。(这里求倒数会引入一个问题，就是分母不可不０，要注意控制，也就是0去负次方的时候)。

再说指数为０：

结果为１．如果同时base为０．　０的０次方在数学上是没有意义的，因此输出０或者１都是可以接受的，要跟面试官说清楚，表示已经考虑到这个边界值了。

错误处理方式有三种：

方法返回值，全局变量，异常。

比如求倒数时就可以try,catch一下。

有个问题，就是double，float类型是有误差的，所以在比较相等的时候，不要用＝＝。而是定义一个equal方法，相差在0.0000001（误差随意）内就表示相等。

Mis_wenwen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫