文章目录
- 前言
- 1.二维数组中的查找
- 2.替换空格
- 3.从尾到头打印链表
- 4.重建二叉树
- 5.旋转数组的最小数字
- 6.斐波那契数列
- 7.跳台阶
- 8.两个栈实现一个队列
- 9.跳台阶变态版
- 10.矩形覆盖
- 11.二进制中1的个数
- 12. 数值的整数次方
- 13.调整数组顺序使奇数位于偶数前面
- 14.链表中倒数第k个节点
- 15.翻转链表
- 16.合并两个排序的链表
- 17.树的子结构
- 18.二叉树的镜像
- 19.顺时针打印矩阵
- 20.包含min函数的栈
- 21.栈的压入、弹出序列
- 22.从上往下打印二叉树
- 23.搜索二叉树的后序遍历序列
- 24. 二叉树中何为某一值得路径
- 25.复杂链表的复制
- 26.二叉搜索树和双向链表
- 27.字符串的排序
- 28.数组中出现次数超过一半的数字
- 29.最小的k个数
- 30.连续子数组的最大和
- 31.整数中1出现的次数
- 32.把数组排成最小的数
- 33.丑数
- 34.第一次出现的字符
- 35.数组中的逆序对
- 36.两个链表的第一个公共节点
- 37.数字在升序数组中出现的次数
- 38.树的深度
- 39.平衡二叉树
- 40.数组中只出现一次的数字
- 41.和为S的连续正数序列
- 42.和为S的两个数字
- 43.左旋转字符串
- 44.翻转单词序列
- 45.扑克牌顺子
- 46.圆圈中最后剩下的士兵
- 47. 求解1~n之和
- 48.不使用加减乘除实现加法
- 49.把字符串变成整数
- 50.数组中重复的数字
- 51.构建乘积数组
- 52.正则表达式匹配
- 53.表达数值的字符串
- 54.字符流中的第一个不重复的字符
- 55.链表中环的入口节点
- 56.删除链表中重复的节点
- 57.二叉树的下一个节点
- 58.对称的二叉树
- 59.按之字形顺序打印二叉树
- 60.将二叉树打印成多行
- 61.序列化二叉树
- 62.二叉搜索树的第k个结点
- 63.数据流中的中位数
- 64.滑动窗口的最大值
- 65.矩阵中的路径
- 66.机器人的运动范围
- 67.剪绳子
- 作者简介
前言
仓库地址:https://github.com/Damaer/CodeSolution
在线文档:https://damaer.github.io/CodeSolution/
题目基本来源于牛客网,或许有个别题目没有,或许解法不够优,这些日后遇到会再更新。现在面试基本都需要算法,如果没有时间刷Leetcode
,把剑指Offer
先刷了也是一种不错的选择,基本能覆盖大部分公司的考察。
算法,我们大部分人在工作中是用不上的,普通人也几乎不会创造出一个多厉害的算法,不必为之太过焦虑,这个时代已经足够焦虑了。你可以把算法当成兴趣,或者看到文章感兴趣的时候,去看看,去试试。如果对某个题目不感兴趣,大可略过不看。
很早之前听过一句话,算法题,可以锻炼一个人知难不退的心态,能够沉下心来思考,不会觉得枯燥,当然,也是有益思维锻炼,但是它不是万能药,不能解决所有的问题,也不是一日之功。
正所谓,冰冻三尺非一日之寒,滴水石穿非一日之功,这是第一版文档,之后会增加解法或者纠正存在的错误。
【作者简介】:
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。个人写作方向:Java源码解析
,JDBC
,Mybatis
,Spring
,redis
,分布式
,剑指Offer
,LeetCode
等,认真写好每一篇文章,不喜欢标题党,不喜欢花里胡哨,大多写系列文章,不能保证我写的都完全正确,但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处,还望指正。
关注公众号领取pdf!!!
1.二维数组中的查找
题目描述
在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
例子
输入一个数组:
num[ 3 ][ 4 ] = [
1 , 4 , 6 , 28 ,
2 , 7 , 32 , 30 ,
10 , 11 , 67 , 79
]
需要查找一个数字 32 ,则返回 true
。
思路 & 解答
暴力破解
直接暴力遍历,但是在最坏的情况是遍历完所有的元素才能获取结果。如果这个数组规模是 n * m
,那么时间复杂度就是 O(n × m)
,没有借助其他的空间,空间复杂度为 O(1)
。
比较查找法
但是我们换一种思路,我们选定左下角的10 ( num[2][0], i = 2, j = 0
)作为起点,如果大于10 ,那么 i + 1
,如果小于 10 ,则 j + 1
,则下一个查找的数字是 11 ,我们知道 32 仍然比 11 大,则往右找到 67 ,继而 32 比 67 小,我们应该往上找,找到了 32 。
如果找 28 ,则是最坏的结果,查找知道数组的右上角结束,这样一来,最坏的结果就是 O(n+m)
。
代码如下:
public class Solution {
public boolean Find(int target, int [][] array) {
int size=array.length;
int length=array[0].length;
int i,j;
for(i=size-1,j=0;i>=0&&i<size&&j>=0&&j<length;){
if(array[i][j]==target){
return true;
}
if(array[i][j]<target){
j++;
continue;
}
if(array[i][j]>target){
i--;
continue;
}
}
return false;
}
}
2.替换空格
题目描述
请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路 & 解答
调用API函数
java
里面有可以直接使用的函数replace()
,直接写成下面这样即可通过,但是这样真的没有意思啊。🤣🤣🤣
public String replaceSpace(StringBuffer str) {
String result = str.toString().replace(" ","%20");
return result;
}
自实现
于是乎,决定自己实现,不直接调用 api.思路如下:
- 1.将字符串转换成为字符数组,遍历一次,统计出空格的个数。
- 2.构建出新的字符数组,初始化的大小=原来的字符数组长度+空格长度x2
- 3.遍历一次,复制,当不为空格时直接复制,当为空格时,则把
%20
这三个字符复制过去。
代码如下:
public class Solution {
public String replaceSpace(StringBuffer str) {
// 转换成为字符数组
char[] originChars= str.toString().toCharArray();
int spaceNum = 0;
// 计算出空格的个数
for (int i = 0; i < originChars.length; i++) {
if (originChars[i] == ' ') {
spaceNum++;
}
}
// 新字符数组的长度
int newCharsLength = originChars.length + 2 * spaceNum;
char[] newChars = new char[newCharsLength];
int newStrIndex = 0;
for (int index= 0; index<=originChars.length - 1; index++) {
if(originChars[index] != ' '){
// 直接复制
newChars[newStrIndex++] = originChars[index];
}else {
// 空格则需要复制三个字符
newChars[newStrIndex++] = '%';
newChars[newStrIndex++] = '2';
newChars[newStrIndex++] = '0';
}
}
// 转成字符串
return new String(newChars);
}
}
c++实现
c++实现差不多,主要是复制的时候从后面往前面开始复制,这样就可以节省一定空间,直接在原来的数组上操作。不需要重新创建一个空间。
class Solution {
public:
void replaceSpace(char *str,int length) {
if(str == NULL || length <= 0){
return;
}
int originalLength = 0;
int spaceNum = 0;
int i;
while(str[i++] != '\0'){
++originalLength;
if(str[i] == ' '){
++spaceNum;
}
}
int newCharsLength = originalLength + 2 * spaceNum;
int indexOriginal = originalLength-1;
int index = newCharsLength-1;
while(indexOriginal >= 0 && index > indexOriginal){
if(str[indexOriginal] == ' '){
str[index--] = '0';
str[index--] = '2';
str[index--] = '%';
}
else{
str[index--] = str[indexOriginal];
}
--indexOriginal;
}
}
};
3.从尾到头打印链表
题目描述
输入一个链表,按链表从尾到头的顺序返回一个ArrayList。
思路 & 解答
🙋♂️🙋♂️首先我们需要想用哪些解法可以解,大概有如下:
- 使用栈
- 使用递归调用
- 头插法
借助栈实现
先把元素里面的元素从头到尾遍历取出放在栈里面,然后再把栈的元素去出来放在ArraList
里面。主要利用了栈的先进后出的规则,这样就可以实现倒序的功能。show you the code
:
/**
* 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) {
Stack<Integer> stack = new Stack<>();
while (listNode != null) {
stack.push(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> results = new ArrayList<>();
while (!stack.isEmpty()) {
results.add(stack.pop());
}
return results;
}
}
递归调用
前面我们能想到栈,那么我们何必自己实现呢?其实方法的调用过程,就是一个天然的栈调用的过程呀,只需要判断当前节点是不是为空,为空则不输出,不为空则递归下一个节点,对下一个节点处理之后,把结果使用ArrayList.addAll()
加到结果中,再把自身加到结果中,emmmmm有道理,说码就码:
/**
* 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) {
ArrayList<Integer> results = new ArrayList<>();
if(listNode!=null){
// 对后面的元素进行处理
results.addAll(printListFromTailToHead(listNode.next));
// 最后添加自身
results.add(listNode.val);
}
return results;
}
}
头插法
我们遍历每一个节点,然后把它插入到头部,这样一直遍历到尾的时候,就相当于将整个链表都反转一遍了,然后再从头到尾遍历放到ArryList
即可。
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ListNode head = new ListNode(-1);
while(listNode!=null){
// 先把当前node的next保存起来
ListNode temp = listNode.next;
// 把当前节点的next指针指向head的下一个节点
listNode.next = head.next;
// 把head的next指向当前节点
head.next = listNode;
// 将遍历的指针指向了遍历的下一个元素
listNode = temp;
}
ArrayList<Integer> results = new ArrayList<>();
head = head.next;
// 遍历输出
while(head!=null){
results.add(head.val);
head = head.next;
}
return results;
}
}
4.重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}
和中序遍历序列{4,7,2,1,5,3,8,6}
,则重建二叉树并返回。
思路 & 解答
我们看上面的图片,首先数据保证了正确性,那么前序的第一个肯定是root
节点,也就是1
,那么我们需要在中序遍历中找到1
的位置,左边就是这个root
的左子树,右边就是root
的右子树。
我们可以举个栗子:对根节点的左子树进行解析:
对右子树进行解析:
只需要不断递归即可,当边界左边大于右边的时候,则停止。
代码如下:
/**
* 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) {
if (pre == null || pre.length == 0 || in == null || in.length == 0) {
return null;
}
TreeNode root = constructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length-1);
return root;
}
TreeNode constructBinaryTree(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn) {
// 不符合条件直接返回null
if (startPre > endPre || startIn > endIn) {
return null;
}
// 构建根节点
TreeNode root = new TreeNode(pre[startPre]);
for (int index = startIn; index <= endIn; index++) {
if (in[index] == pre[startPre]) {
// 左子树
root.left = constructBinaryTree(pre, startPre + 1, startPre + (index - startIn), in, startIn, index - 1);
// 右子树
root.right = constructBinaryTree(pre, (index - startIn) + startPre + 1, endPre, in, index + 1, endIn);
break;
}
}
return root;
}
}
5.旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。
例如数组{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) {
if(array==null||array.length==0){
return 0;
}
if(array.length==1){
return array[0];
}
int max = array[0];
for(int i=1;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
if(array[i]<max){
return array[i];
}
}
return 0;
}
}
二分法
旋转之后的数组其实就是分成两段,比如{3,4,5,1,2}
,可以看到,3
,4
,5
是递增的,但是5
之后1
就是比之前的数小的,这样就可以找到最小值1
。
取出中间元素,和最右边元素比较,如果中间元素大于最右边元素,则证明,最小值存在于中间元素到最右边元素之间的一段。如果中间元素小于最右边元素,则证明,最小值在最左边元素到中间元素之间的一段中。
有一种特殊情况,就是相同元素,这样我们没有办法判断最小的元素位于哪一段,所以只能将右边的边界向左移动,即high--
。
public class Solution {
public static int minNumberInRotateArray(int[] array) {
if (array == null || array.length == 0) {
return 0;
}
if (array.length == 1) {
return array[0];
}
int low = 0, high = array.length - 1;
while (high - low > 1) {
int mid = (low + high) / 2;
if (array[mid] > array[high]) {
low = mid;
} else if (array[mid] < array[high]) {
high = mid;
} else {
high--;
}
}
return Math.min(array[low], array[high]);
}
}
6.斐波那契数列
题目描述
大家都知道斐波那契数列,现在要求输入一个整数n,请你输出斐波那契数列的第n项(从0开始,第0项为0,第1项是1)。(n<=39
)
思路 & 解答
斐波那契数列大家都知道:
直接暴力
思路很直接,利用函数进行递归即可。
public class Solution {
public int Fibonacci(int n) {
if(n==0){
return 0;
}else if(n==1){
return 1;
}else{
return Fibonacci(n-1)+Fibonacci(n-2);
}
}
}
重复利用结果(动态规划)
直接递归会造成很多重复的计算,要是我们把计算结果先存起来,使用的时候再调用,那就可以优化。
public class Solution {
public int Fibonacci(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
int[] nums = new int[n + 1];
nums[0] = 0;
nums[1] = 1;
for (int i = 2; i <= n; i++) {
nums[i] = nums[i - 1] + nums[i - 2];
}
return nums[n];
}
}
7.跳台阶
题目描述
一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。
思路 & 解答
暴力递归
使用递归即可,首先第0
级台阶是0
次,第1
级台阶是1
次,跳上第二级台阶可以选择从0
直接跳到2
,也可以从1
跳到2
。其他情况,我们可以归纳出,要想跳到n
级台阶,最后一步有两种跳法,一种是从n-1
级一次跳一级,一种是从n-2
级一次跳两级。
f ( n ) = { 0 , n = 0 1 , n = 1 2 , n = 2 f ( n − 1 ) + f ( n − 2 ) , n > 2 f(n)=\begin{cases} 0,n=0\\ 1,n=1\\ 2,n=2\\ f(n-1)+f(n-2),n>2 \end{cases} f(n)=⎩⎪⎪⎪⎨⎪⎪⎪⎧0,n=01,n=12,n=2f(n−1)+f(n−2),n>2
public class Solution {
public int JumpFloor(int target) {
if (target == 0) {
return 0;
} else if (target == 1) {
return 1;
} else if (target == 2) {
return 2;
} else {
return JumpFloor(target - 1) + JumpFloor(target - 2);
}
}
}
动态规划
上面的解法会需要多次重复计算,我们可以利用数组将前面的结果存起来,计算的时候直接取出。
public class Solution {
public int JumpFloor(int target) {
int[] nums = new int[target + 1];
if (target == 0) {
return 0;
} else if (target == 1) {
return 1;
} else if (target == 2) {
return 2;
}
nums[0] = 0;
nums[1] = 1;
nums[2] = 2;
for (int i = 3; i <= target; i++) {
nums[i] = nums[i - 1] + nums[i - 2];
}
return nums[target];
}
}
8.两个栈实现一个队列
题目描述
用两个栈来实现一个队列,完成队列的Push
和Pop
操作。 队列中的元素为int
类型。
思路 & 解答
- 栈的特性是先进后出
- 队列的特性是先进先出
有两个栈stack1
,stack2
;
如果有新的数据进入,那么我们可以直接push到stack1;
如果需要取出数据,那么我们优先取出stack2
的数据,如果stack2
里面数据是空的,那么我们需要把所有的stack1
的数据倒入stack2
。再从stack2
取数据。
例如:
(1). push 1–> push 2
(2). pop 1
(3). push 3 --> push 4
(4).pop 2
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.isEmpty()){
return stack2.pop();
}else{
while(!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
9.跳台阶变态版
题目描述
一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路 & 解答
首先青蛙一次可以跳 1 , 2 , 3 到 n 级。假设函数是f(n)
,则:
- 青蛙跳到第一级是
f(1)=1
,只有一种跳法。 - 青蛙跳到第二级,可以是直接跳到第二级,也可以是从第一级直接跳。所以
f(2)=f(1)+1
- 青蛙跳到第三级,可以从第
0
级跳,也可以从第1级跳,也可以从第2
级跳。所以f(3) =f(1)+f(2)+1
; - 依次类推,青蛙跳到第
n
级,可以是从0
,1
,2
,3
…(n-1)
级跳,所以f(n)=f(1)+f(2)+f(3)...+f(n-1)+1
;
因此我们需要双层for
循环即可完成。
public class Solution {
public int JumpFloorII(int target) {
if (target <= 0) {
return 0;
}
int[] nums = new int[target];
nums[0] = 1;
for (int i = 0; i < target; i++) {
int sum = 1;
for (int j = 0; j < i; j++) {
sum += nums[j];
}
nums[i]=sum;
}
return nums[target - 1];
}
}
完成之后我们可以顺便推一下公式:
f ( n ) = f ( 1 ) + f ( 2 ) + . . . + f ( n − 2 ) + f ( n − 1 ) + 1 ; f ( n − 1 ) = f ( 1 ) + f ( 2 ) + . . . + f ( n − 2 ) + 1 ; f ( n ) − f ( n − 1 ) = f ( n − 1 ) ; f ( n ) = 2 ∗ f ( n − 1 ) ; f(n)= f(1)+f(2)+...+f(n-2)+f(n-1)+1;\\ f(n-1)=f(1)+f(2)+...+f(n-2)+1;\\ f(n)-f(n-1)=f(n-1);\\ f(n)=2*f(n-1);\\ f(n)=f(1)+f(2)+...+f(n−2)+f(n−1)+1;f(n−1)=f(1)+f(2)+...+f(n−2)+1;f(n)−f(n−1)=f(n−1);f(n)=2∗f(n−1);
所以最后我们可以推倒出:
f ( n ) = 2 n − 1 f(n) = 2^{n-1} f(n)=2n−1
show you the code:
public class Solution {
public int JumpFloorII(int target) {
return (int) Math.pow(2, target - 1);
}
}
10.矩形覆盖
题目描述
我们可以用2*1
的小矩形横着或者竖着去覆盖更大的矩形。请问用n
个2*1
的小矩形无重叠地覆盖一个2*n
的大矩形,总共有多少种方法?
比如n=3
时,2*3
的矩形块有3
种覆盖方法:
思路 & 解答
递归实现
先说思路,基本是递归,首先如果n
为1
,那么肯定只有一种,f(1)=1
,如果n=2
,f(2)=2
但是n>2
的时候呢?那么我们的思路就可以分为第一次切分长度为1
,和切分长度为2
来计算,也就是剩下的是f(n-1)
和f(n-2)
,两者加起来即可。
f ( n ) = { 0 , n < = 0 1 , n = 1 2 , n = 2 f ( n − 1 ) + f ( n − 2 ) , n > 2 f(n)=\begin{cases} 0,n<=0\\ 1,n=1\\ 2,n=2\\ f(n-1)+f(n-2),n>2 \end{cases} f(n)=⎩⎪⎪⎪⎨⎪⎪⎪⎧0,n<=01,n=12,n=2f(n−1)+f(n−2),n>2
递归写法代码如下:
public class Solution {
public int RectCover(int target) {
if(target<=0){
return 0;
}else if(target==1){
return 1;
}else if(target==2){
return 2;
}else {
return RectCover(target-1)+RectCover(target-2);
}
}
}
非递归实现
如果我不想使用递归呢?那么直接不断地把前面两个数加起来赋值给当前的数字即可。
public class Solution {
public int RectCover(int target) {
if (target <= 0) {
return 0;
} else if (target < 3) {
return target;
} else {
int num1 = 1;
int num2 = 2;
int result = 0;
for (int i = 3; i <= target; i++) {
result = num1 + num2;
num1 = num2;
num2 = result;
}
return result;
}
}
}
11.二进制中1的个数
题目描述
输入一个整数,输出该数32位二进制表示中1的个数。其中负数用补码表示。
思路 & 解答
错误解答(不考虑负数)
首先说一个错误的解法,很多人可能会想到,那就是不断对2取余数。但是这种做法有个致命的缺陷,那就是忽略了负数,负数使用补码表示的时候,是取反之后加一,而且
public class Solution {
public int NumberOf1(int n) {
int num = 0;
while (n != 0) {
int tmp = n % 2;
if (tmp == 1||tmp==-1) ++num;
n /= 2;
}
return num;
}
}
位移算法
移位算法,把整数当成二进制,不断向右移位和1进行与计算。利用了所有数和1进行与计算,结果为1则证明最后一位是1。
于是我们代码可以写成这样,但是这样也是有问题的!!!:
public class Solution {
public int NumberOf1(int n) {
int num=0;
while (n != 0) {
if ((n & 1)==1){
++num;
}
n = n>>1;
}
return num;
}
}
上面代码的问题在于忽略了负数右移,其实第一位还是会补1,所以还是负数。就是说-1其实右移动之后还是-1,这样判断是无效的,而且会死循环。
既然输入的n没办法右移,那么我们把1左移是不是就解决这个问题了呢?是的!
正确代码如下:
public class Solution {
public int NumberOf1(int n) {
int num = 0, flag = 1;
while (flag != 0) {
if ((n & flag) != 0) {
num++;
}
flag <<= 1;
}
return num;
}
}
除此之外,还有其他做法么?还有一种做法的不断把最右边的1变成0,那就是利用n=n&(n-1)
,比如7的二进制是111,那么7&6=111&110=110=6,就完美把最后一位1变成0了,6的二进制是110,6&5=110&101=100=4,也把最后一位1变成了0.
负数可不可以?可以!比如:
32位-7 = 11111111111111111111111111111001 ,
32位-8 = 11111111111111111111111111111000,
-7&-8 = 11111111111111111111111111111000
所以这种思路针对负数也是正确的:
public class Solution {
public int NumberOf1(int n) {
int num = 0;
while (n != 0) {
num++;
n &= (n - 1);
}
return num;
}
}
API调用(不推荐)
还有一种思路那就是直接调用java的api把整数,转成字符串,遍历一次获取1的个数,可以但是不提倡,因为本题考查的是位运算,而不是api使用和for循环。
public class Solution {
public int NumberOf1(int n) {
int t = 0;
String str = Integer.toBinaryString(n);
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == '1') {
t++;
}
}
return t;
}
}
12. 数值的整数次方
题目描述
给定一个double
类型的浮点数base
和int
类型的整数exponent
。求base的exponent
次方。保证base
和exponent
不同时为0
。
思路 & 解答
首先题目中的double
类型应该不能拆解,但是int
类型的整数exponet
我们可以做点文章,我们平时求次方的时候,假设有个x
的4次方,我们通常是求出一个x的平方数x^2
,然后两个x^2
相乘就可以得出x^4
。
这里思路也一样,使用递归,同时考虑边界条件。
如果指数是负数,则先取反,最后取结果的倒数即可。
P o w e r ( b a s e , e x ) = { b a s e ∗ P o w e r ( b a s e , e x − 1 ) , e x 取 余 2 = 1 P o w e r ( b a s e , e x / 2 ) ∗ P o w e r ( b a s e , e x / 2 ) , e x 取 余 2 = 0 Power(base,ex)=\begin{cases} base*Power(base,ex-1),ex取余2=1 \\ Power(base,ex/2)*Power(base,ex/2),ex取余2=0\\ \end{cases} Power(base,ex)={ base∗Power(base,ex−1),ex取余2=1Power(base,ex/2)∗Power(base,ex/2),ex取余2=0
public double Power(double base, int exponent) {
if (exponent == 0) {
// 指数为0则直接返回1
return 1;
}
if (base == 0) {
//底数为0直接返回0
return 0;
}
// 判断指数是否为负数
boolean isNegative = false;
if (exponent < 1) {
exponent = -exponent;
isNegative = true;
}
double result;
if (exponent % 2 == 1) {
result = base * Power(base, exponent - 1);
} else {
double temp = Power(base, exponent / 2);
result = temp * temp;
}
return isNegative ? (1.0 / result) : result;
}
13.调整数组顺序使奇数位于偶数前面
题目描述
输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。
思路 & 解答
空间换时间
用空间换时间做法,就是新建一个数组,copy
一份,先计算出奇数的个数,也就是能够知道第一个偶数应该放在数组的哪一个位置,然后再遍历一次,依次放到对应的位置即可。
public class Solution {
public void reOrderArray(int[] nums) {
// 奇数个数
int oddCnt = 0;
for (int x : nums)
if (x % 2 == 1)
oddCnt++;
int[] copy = nums.clone();
int i = 0, j = oddCnt;
for (int num : copy) {
if (num % 2 == 1)
nums[i++] = num;
else
nums[j++] = num;
}
}
}
冒泡
第二种做法,时间复杂度为O(n2),类似冒泡,将找到的奇数不断往前面冒泡,直到前面排好奇数的位置。
public class Solution {
public void reOrderArray(int [] array) {
// 已经摆好的奇数个数
int numOfOdd = 0;
for (int i = 0; i < array.length; i++) {
<